@tony.ganchev/eslint-plugin-header 3.2.5 → 3.2.6

package/lib/rules/eslint-utils.js

@@ -36,7 +36,7 @@ module.exports = {
      * @param {RuleContext} context ESLint execution context.
      * @returns {SourceCode} The source-code object.
      */
-    contextSourceCode: function(context) {
+    contextSourceCode: function (context) {
         return context.sourceCode
             || /** @type {RuleContext & { getSourceCode: () => SourceCode }} */(context).getSourceCode();
     }

package/lib/rules/header.js

@@ -33,8 +33,9 @@ const { description, recommended } = require("./header.docs");
 const { lineEndingOptions, commentTypeOptions, schema } = require("./header.schema");
 
 /**
- * @import { Linter, Rule } from "eslint"
- * @import { Comment, SourceLocation, Program } from "estree"
+ * @import { JSSyntaxElement, Linter, Rule, SourceCode } from "eslint"
+ * @import { Comment, SourceLocation } from "estree"
+ * @import { ViolationReport } from "@eslint/core";
  * @typedef {Rule.NodeListener} NodeListener
  * @typedef {Rule.ReportFixer} ReportFixer
  * @typedef {Rule.RuleFixer} RuleFixer
@@ -175,53 +176,28 @@ function match(actual, expected) {
  */
 function excludeShebangs(comments) {
     /** @type {Comment[]} */
-    return comments.filter(function(comment) {
+    return comments.filter(function (comment) {
         return comment.type !== "Shebang";
     });
 }
 
-/**
- * TypeScript helper to confirm defined type.
- * @template T Target type to validate for definiteness.
- * @param {T | undefined} val The value to validate.
- * @returns {asserts val is T} Validates defined type.
- */
-function assertDefined(val) {
-    assert.strict.notEqual(typeof val, "undefined");
-}
-
-/**
- * TypeScript helper to confirm non-null type.
- * @template T Target type to validate is non-null.
- * @param {T | null} val The value to validate.
- * @returns {asserts val is T} Validates non-null type.
- */
-function assertNotNull(val) {
-    assert.strict.notEqual(val, null);
-}
-
 /**
  * Returns either the first block comment or the first set of line comments that
  * are ONLY separated by a single newline. Note that this does not actually
  * check if they are at the start of the file since that is already checked by
  * `hasHeader()`.
- * @param {RuleContext} context ESLint execution environment.
+ * @param {SourceCode} sourceCode AST.
  * @returns {Comment[]} Lines That constitute the leading comment.
  */
-function getLeadingComments(context) {
-    const sourceCode = contextSourceCode(context);
+function getLeadingComments(sourceCode) {
     const all = excludeShebangs(sourceCode.getAllComments());
-    assert.ok(all);
-    assert.ok(all.length);
     if (all[0].type.toLowerCase() === commentTypeOptions.block) {
         return [all[0]];
     }
     let i = 1;
     for (; i < all.length; ++i) {
-        const previousRange = all[i - 1].range;
-        assertDefined(previousRange);
-        const currentRange = all[i].range;
-        assertDefined(currentRange);
+        const previousRange = /** @type {[number, number]} */ (all[i - 1].range);
+        const currentRange = /** @type {[number, number]} */ (all[i].range);
         const txt = sourceCode.text.slice(previousRange[1], currentRange[0]);
         if (!txt.match(/^(\r\n|\r|\n)$/)) {
             break;
@@ -257,14 +233,10 @@ function genCommentBody(commentType, textArray, eol) {
 function genCommentsRange(comments) {
     assert.ok(comments.length);
     const firstComment = comments[0];
-    assertDefined(firstComment);
-    const firstCommentRange = firstComment.range;
-    assertDefined(firstCommentRange);
+    const firstCommentRange = /** @type {[number, number]} */ (firstComment.range);
     const start = firstCommentRange[0];
     const lastComment = comments.slice(-1)[0];
-    assertDefined(lastComment);
-    const lastCommentRange = lastComment.range;
-    assertDefined(lastCommentRange);
+    const lastCommentRange = /** @type {[number, number]} */ (lastComment.range);
     const end = lastCommentRange[1];
     return [start, end];
 }
@@ -292,17 +264,16 @@ function leadingEmptyLines(src) {
 /**
  * Factory for fixer that adds a missing header.
  * @param {CommentType} commentType Type of comment to use.
- * @param {RuleContext} context ESLint execution runtime.
+ * @param {SourceCode} sourceCode AST.
  * @param {string[]} headerLines Lines of the header comment.
  * @param {LineEnding} eol End-of-line characters.
  * @param {number} numNewlines Number of trailing lines after the comment.
  * @returns {ReportFixer} The fix to apply.
  */
-function genPrependFixer(commentType, context, headerLines, eol, numNewlines) {
-    return function(fixer) {
+function genPrependFixer(commentType, sourceCode, headerLines, eol, numNewlines) {
+    return function (fixer) {
         let insertPos = 0;
         let newHeader = genCommentBody(commentType, headerLines, eol);
-        const sourceCode = contextSourceCode(context);
         if (sourceCode.text.startsWith("#!")) {
             const firstNewLinePos = sourceCode.text.indexOf("\n");
             insertPos = firstNewLinePos === -1 ? sourceCode.text.length : firstNewLinePos + 1;
@@ -323,17 +294,17 @@ function genPrependFixer(commentType, context, headerLines, eol, numNewlines) {
 /**
  * Factory for fixer that replaces an incorrect header.
  * @param {CommentType} commentType Type of comment to use.
- * @param {RuleContext} context ESLint execution context.
+ * @param {SourceCode} sourceCode AST.
  * @param {Comment[]} leadingComments Comment elements to replace.
  * @param {string[]} headerLines Lines of the header comment.
  * @param {LineEnding} eol End-of-line characters.
  * @param {number} numNewlines Number of trailing lines after the comment.
  * @returns {ReportFixer} The fix to apply.
  */
-function genReplaceFixer(commentType, context, leadingComments, headerLines, eol, numNewlines) {
-    return function(fixer) {
+function genReplaceFixer(commentType, sourceCode, leadingComments, headerLines, eol, numNewlines) {
+    return function (fixer) {
         const commentRange = genCommentsRange(leadingComments);
-        const emptyLines = leadingEmptyLines(contextSourceCode(context).text.substring(commentRange[1]));
+        const emptyLines = leadingEmptyLines(sourceCode.text.substring(commentRange[1]));
         const missingNewlines = Math.max(0, numNewlines - emptyLines);
         const eols = eol.repeat(missingNewlines);
         return fixer.replaceTextRange(
@@ -352,7 +323,7 @@ function genReplaceFixer(commentType, context, leadingComments, headerLines, eol
  * @returns {ReportFixer} The fix to apply.
  */
 function genEmptyLinesFixer(leadingComments, eol, missingEmptyLinesCount) {
-    return function(fixer) {
+    return function (fixer) {
         return fixer.insertTextAfterRange(
             genCommentsRange(leadingComments),
             eol.repeat(missingEmptyLinesCount)
@@ -487,31 +458,19 @@ function isFileBasedHeaderConfig(config) {
 }
 
 /**
- * Type guard for `InlineConfig`.
- * @param {FileBasedConfig | InlineConfig} config The header configuration.
- * @returns {asserts config is InlineConfig} Asserts `config` is
- * `LineBasedConfig`.
+ * Transforms file template-based matching rules to inline rules for further
+ * use.
+ * @param {FileBasedConfig | InlineConfig} matcher The matching rule.
+ * @returns {InlineConfig} The resulting normalized configuration.
  */
-function assertLineBasedHeaderConfig(config) {
-    assert.ok(Object.prototype.hasOwnProperty.call(config, "lines"));
-}
-
-/**
- * Transforms a set of new-style options adding defaults and standardizing on
- * one of multiple config styles.
- * @param {HeaderOptions} originalOptions New-style options to normalize.
- * @returns {HeaderOptions} Normalized options.
- */
-function normalizeOptions(originalOptions) {
-    const options = structuredClone(originalOptions);
-
-    if (isFileBasedHeaderConfig(originalOptions.header)) {
-        const text = fs.readFileSync(originalOptions.header.file, originalOptions.header.encoding || "utf8");
+function normalizeMatchingRules(matcher) {
+    if (isFileBasedHeaderConfig(matcher)) {
+        const text = fs.readFileSync(matcher.file, matcher.encoding || "utf8");
         const [commentType, lines] = commentParser(text);
-        options.header = { commentType, lines };
+        return { commentType, lines };
     }
-    assertLineBasedHeaderConfig(options.header);
-    options.header.lines = options.header.lines.flatMap(
+    const commentType = matcher.commentType;
+    const lines = matcher.lines.flatMap(
         (line) => {
             if (typeof line === "string") {
                 return /** @type {HeaderLine[]} */(line.split(/\r?\n/));
@@ -529,6 +488,19 @@ function normalizeOptions(originalOptions) {
             }
             return [{ pattern }];
         });
+    return { commentType, lines };
+}
+
+/**
+ * Transforms a set of new-style options adding defaults and standardizing on
+ * one of multiple config styles.
+ * @param {HeaderOptions} originalOptions New-style options to normalize.
+ * @returns {HeaderOptions} Normalized options.
+ */
+function normalizeOptions(originalOptions) {
+    const options = structuredClone(originalOptions);
+
+    options.header = normalizeMatchingRules(originalOptions.header);
 
     if (!options.lineEndings) {
         options.lineEndings = "os";
@@ -558,9 +530,7 @@ function normalizeOptions(originalOptions) {
  */
 function missingEmptyLinesViolationLoc(leadingComments, actualEmptyLines) {
     assert.ok(leadingComments);
-    const loc = leadingComments[leadingComments.length - 1].loc;
-    assertDefined(loc);
-    assertNotNull(loc);
+    const loc = /** @type {SourceLocation} */ (leadingComments[leadingComments.length - 1].loc);
     const lastCommentLineLocEnd = loc.end;
     return {
         start: lastCommentLineLocEnd,
@@ -571,6 +541,314 @@ function missingEmptyLinesViolationLoc(leadingComments, actualEmptyLines) {
     };
 }
 
+/**
+ * Matches comments against of header content-matching rules. An object performs
+ * a number of expensive operations only once and thus can be used multiple
+ * times to test different comments.
+ */
+class CommentMatcher {
+    /**
+     * Initializes the matcher for a specific comment-matching rules.
+     * @param {InlineConfig} headerConfig Content-matching rules.
+     * @param {string} eol The EOL characters used.
+     * @param {number} numLines The requirred minimum number of trailing empty
+     * lines.
+     */
+    constructor(headerConfig, eol, numLines) {
+        this.commentType = headerConfig.commentType;
+        this.headerLines = headerConfig.lines.map((line) => isPattern(line) ? line.pattern : line);
+        this.eol = eol;
+        this.numLines = numLines;
+    }
+
+    /**
+     * Performs a validation of a comment against a header matching
+     * configuration.
+     * @param {Comment[]} leadingComments The block comment or sequence of line
+     * comments to test.
+     * @param {SourceCode} sourceCode The source code AST.
+     * @returns {ViolationReport<JSSyntaxElement, string> | null} If set a
+     * violation report to pass back to ESLint or interpret as necessary.
+     */
+    validate(leadingComments, sourceCode) {
+
+        const firstLeadingCommentLoc = /** @type {SourceLocation} */ (leadingComments[0].loc);
+        const firstLeadingCommentRange = /** @type {[number, number]} */ (leadingComments[0].range);
+
+        const lastLeadingCommentLoc = /** @type {SourceLocation} */ (leadingComments[leadingComments.length - 1].loc);
+
+        if (leadingComments[0].type.toLowerCase() !== this.commentType) {
+            return {
+                loc: {
+                    start: firstLeadingCommentLoc.start,
+                    end: lastLeadingCommentLoc.end
+                },
+                messageId: "incorrectCommentType",
+                data: {
+                    commentType: this.commentType
+                },
+            };
+        }
+        if (this.commentType === commentTypeOptions.line) {
+            if (this.headerLines.length === 1) {
+                const leadingCommentValues = leadingComments.map((c) => c.value);
+                if (
+                    !match(leadingCommentValues.join("\n"), this.headerLines[0])
+                    && !match(leadingCommentValues.join("\r\n"), this.headerLines[0])
+                ) {
+                    return {
+                        loc: {
+                            start: firstLeadingCommentLoc.start,
+                            end: lastLeadingCommentLoc.end
+                        },
+                        messageId: "incorrectHeader",
+                    };
+                }
+            } else {
+                for (let i = 0; i < this.headerLines.length; i++) {
+                    if (leadingComments.length - 1 < i) {
+                        return {
+                            loc: {
+                                start: lastLeadingCommentLoc.end,
+                                end: lastLeadingCommentLoc.end
+                            },
+                            messageId: "headerTooShort",
+                            data: {
+                                remainder: this.headerLines.slice(i).join(this.eol)
+                            },
+                        };
+                    }
+                    const headerLine = this.headerLines[i];
+                    const comment = leadingComments[i];
+                    const commentLoc = /** @type {SourceLocation} */ (comment.loc);
+                    if (typeof headerLine === "string") {
+                        const leadingCommentLength = comment.value.length;
+                        const headerLineLength = headerLine.length;
+                        for (let j = 0; j < Math.min(leadingCommentLength, headerLineLength); j++) {
+                            if (comment.value[j] !== headerLine[j]) {
+                                return {
+                                    loc: {
+                                        start: {
+                                            column: "//".length + j,
+                                            line: commentLoc.start.line
+                                        },
+                                        end: commentLoc.end
+                                    },
+                                    messageId: "headerLineMismatchAtPos",
+                                    data: {
+                                        expected: headerLine.substring(j)
+                                    },
+                                };
+                            }
+                        }
+                        if (leadingCommentLength < headerLineLength) {
+                            return {
+                                loc: {
+                                    start: commentLoc.end,
+                                    end: commentLoc.end,
+                                },
+                                messageId: "headerLineTooShort",
+                                data: {
+                                    remainder: headerLine.substring(leadingCommentLength)
+                                },
+                            };
+                        }
+                        if (leadingCommentLength > headerLineLength) {
+                            return {
+                                loc: {
+                                    start: {
+                                        column: "//".length + headerLineLength,
+                                        line: commentLoc.start.line
+                                    },
+                                    end: commentLoc.end,
+                                },
+                                messageId: "headerLineTooLong",
+                            };
+                        }
+                    } else {
+                        if (!match(comment.value, headerLine)) {
+                            return {
+                                loc: {
+                                    start: {
+                                        column: "//".length,
+                                        line: commentLoc.start.line,
+                                    },
+                                    end: commentLoc.end,
+                                },
+                                messageId: "incorrectHeaderLine",
+                                data: {
+                                    pattern: headerLine.toString()
+                                },
+                            };
+                        }
+                    }
+                }
+            }
+
+            const commentRange = /** @type {[number, number]} */ (leadingComments[this.headerLines.length - 1].range);
+            const actualLeadingEmptyLines = leadingEmptyLines(sourceCode.text.substring(commentRange[1]));
+            const missingEmptyLines = this.numLines - actualLeadingEmptyLines;
+            if (missingEmptyLines > 0) {
+                return {
+                    loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
+                    messageId: "noNewlineAfterHeader",
+                    data: {
+                        expected: this.numLines,
+                        actual: actualLeadingEmptyLines
+                    },
+                };
+            }
+
+            return null;
+        }
+        // if block comment pattern has more than 1 line, we also split the
+        // comment
+        let leadingLines = [leadingComments[0].value];
+        if (this.headerLines.length > 1) {
+            leadingLines = leadingComments[0].value.split(/\r?\n/);
+        }
+
+        /** @type {null | string} */
+        let errorMessageId = null;
+        /** @type {undefined | Record<string, string>} */
+        let errorMessageData;
+        /** @type {null | SourceLocation} */
+        let errorMessageLoc = null;
+        for (let i = 0; i < this.headerLines.length; i++) {
+            if (leadingLines.length - 1 < i) {
+                return {
+                    loc: {
+                        start: lastLeadingCommentLoc.end,
+                        end: lastLeadingCommentLoc.end
+                    },
+                    messageId: "headerTooShort",
+                    data: {
+                        remainder: this.headerLines.slice(i).join(this.eol)
+                    },
+                };
+            }
+            const leadingLine = leadingLines[i];
+            const headerLine = this.headerLines[i];
+            if (typeof headerLine === "string") {
+                for (let j = 0; j < Math.min(leadingLine.length, headerLine.length); j++) {
+                    if (leadingLine[j] !== headerLine[j]) {
+                        errorMessageId = "headerLineMismatchAtPos";
+                        const columnOffset = i === 0 ? "/*".length : 0;
+                        const line = firstLeadingCommentLoc.start.line + i;
+                        errorMessageLoc = {
+                            start: {
+                                column: columnOffset + j,
+                                line
+                            },
+                            end: {
+                                column: columnOffset + leadingLine.length,
+                                line
+                            }
+                        };
+                        errorMessageData = {
+                            expected: headerLine.substring(j)
+                        };
+                        break;
+                    }
+                }
+                if (errorMessageId) {
+                    break;
+                }
+                if (leadingLine.length < headerLine.length) {
+                    errorMessageId = "headerLineTooShort";
+                    const startColumn = (i === 0 ? "/*".length : 0) + leadingLine.length;
+                    errorMessageLoc = {
+                        start: {
+                            column: startColumn,
+                            line: firstLeadingCommentLoc.start.line + i
+                        },
+                        end: {
+                            column: startColumn + 1,
+                            line: firstLeadingCommentLoc.start.line + i
+                        }
+                    };
+                    errorMessageData = {
+                        remainder: headerLine.substring(leadingLine.length)
+                    };
+                    break;
+                }
+                if (leadingLine.length > headerLine.length) {
+                    errorMessageId = "headerLineTooLong";
+                    errorMessageLoc = {
+                        start: {
+                            column: (i === 0 ? "/*".length : 0) + headerLine.length,
+                            line: firstLeadingCommentLoc.start.line + i
+                        },
+                        end: {
+                            column: (i === 0 ? "/*".length : 0) + leadingLine.length,
+                            line: firstLeadingCommentLoc.start.line + i
+                        }
+                    };
+                    break;
+                }
+            } else {
+                if (!match(leadingLine, headerLine)) {
+                    errorMessageId = "incorrectHeaderLine";
+                    errorMessageData = {
+                        pattern: headerLine.toString()
+                    };
+                    const columnOffset = i === 0 ? "/*".length : 0;
+                    errorMessageLoc = {
+                        start: {
+                            column: columnOffset + 0,
+                            line: firstLeadingCommentLoc.start.line + i
+                        },
+                        end: {
+                            column: columnOffset + leadingLine.length,
+                            line: firstLeadingCommentLoc.start.line + i
+                        }
+                    };
+                    break;
+                }
+            }
+        }
+
+        if (!errorMessageId && leadingLines.length > this.headerLines.length) {
+            errorMessageId = "headerTooLong";
+            errorMessageLoc = {
+                start: {
+                    column: (this.headerLines.length === 0 ? "/*".length : 0) + 0,
+                    line: firstLeadingCommentLoc.start.line + this.headerLines.length
+                },
+                end: {
+                    column: lastLeadingCommentLoc.end.column - "*/".length,
+                    line: lastLeadingCommentLoc.end.line
+                }
+            };
+        }
+
+        if (errorMessageId) {
+            return {
+                loc: /** @type {SourceLocation} */ (errorMessageLoc),
+                messageId: errorMessageId,
+                data: errorMessageData,
+            };
+        }
+
+        const actualLeadingEmptyLines =
+            leadingEmptyLines(sourceCode.text.substring(firstLeadingCommentRange[1]));
+        const missingEmptyLines = this.numLines - actualLeadingEmptyLines;
+        if (missingEmptyLines > 0) {
+            return {
+                loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
+                messageId: "noNewlineAfterHeader",
+                data: {
+                    expected: this.numLines,
+                    actual: actualLeadingEmptyLines
+                },
+            };
+        }
+
+        return null;
+    }
+}
+
+
 /** @type {Rule.RuleModule} */
 const headerRule = {
     meta: {
@@ -609,50 +887,37 @@ const headerRule = {
      * @param {RuleContext} context ESLint rule execution context.
      * @returns {NodeListener} The rule definition.
      */
-    create: function(context) {
+    create: function (context) {
 
-        const newStyleOptions = transformLegacyOptions(/** @type {AllHeaderOptions} */ (context.options));
+        const newStyleOptions = transformLegacyOptions(/** @type {AllHeaderOptions} */(context.options));
         const options = normalizeOptions(newStyleOptions);
 
-        assertLineBasedHeaderConfig(options.header);
-        const commentType = /** @type {CommentType} */ (options.header.commentType);
-
         const eol = getEol(
-            /** @type {LineEndingOption} */ (options.lineEndings)
+            /** @type {LineEndingOption} */(options.lineEndings)
         );
 
-        /** @type {string[]} */
-        let fixLines = [];
-        // If any of the lines are regular expressions, then we can't
-        // automatically fix them. We set this to true below once we
-        // ensure none of the lines are of type RegExp
-        let canFix = true;
-        const headerLines = options.header.lines.map(function(line) {
-            // Can only fix regex option if a template is also provided
+        const header = /** @type {InlineConfig} */ (options.header);
+
+        const canFix = !header.lines.some((line) => isPattern(line) && !("template" in line));
+
+        const fixLines = header.lines.map((line) => {
             if (isPattern(line)) {
-                if (Object.prototype.hasOwnProperty.call(line, "template")) {
-                    fixLines.push(/** @type {string} */ (line.template));
-                } else {
-                    canFix = false;
-                    fixLines.push("");
-                }
-                return line.pattern;
-            } else {
-                fixLines.push(/** @type {string} */ (line));
-                return line;
+                return ("template" in line) ? /** @type {string} */(line.template) : "";
             }
+            return /** @type {string} */(line);
         });
 
-
         const numLines = /** @type {number} */ (options.trailingEmptyLines?.minimum);
 
+        const headerMatcher = new CommentMatcher(header, eol, numLines);
+
         return {
             /**
              * Hooks into the processing of the overall script node to do the
              * header validation.
              * @returns {void}
              */
-            Program: function() {
+            Program: function () {
                 const sourceCode = contextSourceCode(context);
                 if (!hasHeader(sourceCode.text)) {
                     const hasShebang = sourceCode.text.startsWith("#!");
@@ -669,41 +934,10 @@ const headerRule = {
                             }
                         },
                         messageId: "missingHeader",
-                        fix: genPrependFixer(
-                            commentType,
-                            context,
-                            fixLines,
-                            eol,
-                            numLines)
-                    });
-                    return;
-                }
-                const leadingComments = getLeadingComments(context);
-                const firstLeadingCommentLoc = leadingComments[0].loc;
-                const firstLeadingCommentRange = leadingComments[0].range;
-                assertDefined(firstLeadingCommentRange);
-
-                const lastLeadingCommentLoc = leadingComments[leadingComments.length - 1].loc;
-
-                if (leadingComments[0].type.toLowerCase() !== commentType) {
-                    assertDefined(firstLeadingCommentLoc);
-                    assertNotNull(firstLeadingCommentLoc);
-                    assertDefined(lastLeadingCommentLoc);
-                    assertNotNull(lastLeadingCommentLoc);
-                    context.report({
-                        loc: {
-                            start: firstLeadingCommentLoc.start,
-                            end: lastLeadingCommentLoc.end
-                        },
-                        messageId: "incorrectCommentType",
-                        data: {
-                            commentType: commentType
-                        },
                         fix: canFix
-                            ? genReplaceFixer(
-                                commentType,
-                                context,
-                                leadingComments,
+                            ? genPrependFixer(
+                                headerMatcher.commentType,
+                                sourceCode,
                                 fixLines,
                                 eol,
                                 numLines)
@@ -711,365 +945,25 @@ const headerRule = {
                     });
                     return;
                 }
-                if (commentType === commentTypeOptions.line) {
-                    if (headerLines.length === 1) {
-                        const leadingCommentValues = leadingComments.map((c) => c.value);
-                        if (
-                            !match(leadingCommentValues.join("\n"), headerLines[0])
-                            && !match(leadingCommentValues.join("\r\n"), headerLines[0])
-                        ) {
-                            assertDefined(firstLeadingCommentLoc);
-                            assertNotNull(firstLeadingCommentLoc);
-                            assertDefined(lastLeadingCommentLoc);
-                            assertNotNull(lastLeadingCommentLoc);
-                            context.report({
-                                loc: {
-                                    start: firstLeadingCommentLoc.start,
-                                    end: lastLeadingCommentLoc.end
-                                },
-                                messageId: "incorrectHeader",
-                                fix: canFix
-                                    ? genReplaceFixer(
-                                        commentType,
-                                        context,
-                                        leadingComments,
-                                        fixLines,
-                                        eol,
-                                        numLines)
-                                    : null
-                            });
-                            return;
-                        }
-                    } else {
-                        for (let i = 0; i < headerLines.length; i++) {
-                            if (leadingComments.length - 1 < i) {
-                                assertDefined(lastLeadingCommentLoc);
-                                assertNotNull(lastLeadingCommentLoc);
-                                context.report({
-                                    loc: {
-                                        start: lastLeadingCommentLoc.end,
-                                        end: lastLeadingCommentLoc.end
-                                    },
-                                    messageId: "headerTooShort",
-                                    data: {
-                                        remainder: headerLines.slice(i).join(eol)
-                                    },
-                                    fix: canFix
-                                        ? genReplaceFixer(
-                                            commentType,
-                                            context,
-                                            leadingComments,
-                                            fixLines,
-                                            eol,
-                                            numLines)
-                                        : null
-                                });
-                                return;
-                            }
-                            const headerLine = headerLines[i];
-                            const comment = leadingComments[i];
-                            const commentLoc = comment.loc;
-                            assertDefined(commentLoc);
-                            assertNotNull(commentLoc);
-                            if (typeof headerLine === "string") {
-                                const leadingCommentLength = comment.value.length;
-                                const headerLineLength = headerLine.length;
-                                for (let j = 0; j < Math.min(leadingCommentLength, headerLineLength); j++) {
-                                    if (comment.value[j] !== headerLine[j]) {
-                                        context.report({
-                                            loc: {
-                                                start: {
-                                                    column: "//".length + j,
-                                                    line: commentLoc.start.line
-                                                },
-                                                end: commentLoc.end
-                                            },
-                                            messageId: "headerLineMismatchAtPos",
-                                            data: {
-                                                expected: headerLine.substring(j)
-                                            },
-                                            fix: genReplaceFixer(
-                                                commentType,
-                                                context,
-                                                leadingComments,
-                                                fixLines,
-                                                eol,
-                                                numLines)
-                                        });
-                                        return;
-                                    }
-                                }
-                                if (leadingCommentLength < headerLineLength) {
-                                    context.report({
-                                        loc: {
-                                            start: commentLoc.end,
-                                            end: commentLoc.end,
-                                        },
-                                        messageId: "headerLineTooShort",
-                                        data: {
-                                            remainder: headerLine.substring(leadingCommentLength)
-                                        },
-                                        fix: canFix
-                                            ? genReplaceFixer(
-                                                commentType,
-                                                context,
-                                                leadingComments,
-                                                fixLines,
-                                                eol,
-                                                numLines)
-                                            : null
-                                    });
-                                    return;
-                                }
-                                if (leadingCommentLength > headerLineLength) {
-                                    context.report({
-                                        loc: {
-                                            start: {
-                                                column: "//".length + headerLineLength,
-                                                line: commentLoc.start.line
-                                            },
-                                            end: commentLoc.end,
-                                        },
-                                        messageId: "headerLineTooLong",
-                                        fix: canFix
-                                            ? genReplaceFixer(
-                                                commentType,
-                                                context,
-                                                leadingComments,
-                                                fixLines,
-                                                eol,
-                                                numLines)
-                                            : null
-                                    });
-                                    return;
-                                }
-                            } else {
-                                if (!match(comment.value, headerLine)) {
-                                    context.report({
-                                        loc: {
-                                            start: {
-                                                column: "//".length,
-                                                line: commentLoc.start.line,
-                                            },
-                                            end: commentLoc.end,
-                                        },
-                                        messageId: "incorrectHeaderLine",
-                                        data: {
-                                            pattern: headerLine.toString()
-                                        },
-                                        fix: canFix
-                                            ? genReplaceFixer(
-                                                commentType,
-                                                context,
-                                                leadingComments,
-                                                fixLines,
-                                                eol,
-                                                numLines)
-                                            : null
-                                    });
-                                    return;
-                                }
-                            }
-                        }
-                    }
-
-                    const commentRange = leadingComments[headerLines.length - 1].range;
-                    assertDefined(commentRange);
-                    const actualLeadingEmptyLines = leadingEmptyLines(sourceCode.text.substring(commentRange[1]));
-                    const missingEmptyLines = numLines - actualLeadingEmptyLines;
-                    if (missingEmptyLines > 0) {
-                        context.report({
-                            loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
-                            messageId: "noNewlineAfterHeader",
-                            data: {
-                                expected: numLines,
-                                actual: actualLeadingEmptyLines
-                            },
-                            fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
-                        });
-                    }
-                    return;
-                }
-                // if block comment pattern has more than 1 line, we also split
-                // the comment
-                let leadingLines = [leadingComments[0].value];
-                if (headerLines.length > 1) {
-                    leadingLines = leadingComments[0].value.split(/\r?\n/);
-                }
-
-                /** @type {null | string} */
-                let errorMessageId = null;
-                /** @type {undefined | Record<string, string>} */
-                let errorMessageData;
-                /** @type {null | SourceLocation} */
-                let errorMessageLoc = null;
-                for (let i = 0; i < headerLines.length; i++) {
-                    if (leadingLines.length - 1 < i) {
-                        assertDefined(lastLeadingCommentLoc);
-                        assertNotNull(lastLeadingCommentLoc);
-                        context.report({
-                            loc: {
-                                start: lastLeadingCommentLoc.end,
-                                end: lastLeadingCommentLoc.end
-                            },
-                            messageId: "headerTooShort",
-                            data: {
-                                remainder: headerLines.slice(i).join(eol)
-                            },
-                            fix: canFix
-                                ? genReplaceFixer(
-                                    commentType,
-                                    context,
-                                    leadingComments,
-                                    fixLines,
-                                    eol,
-                                    numLines)
-                                : null
-                        });
-                        return;
-                    }
-                    const leadingLine = leadingLines[i];
-                    const headerLine = headerLines[i];
-                    if (typeof headerLine === "string") {
-                        for (let j = 0; j < Math.min(leadingLine.length, headerLine.length); j++) {
-                            if (leadingLine[j] !== headerLine[j]) {
-                                errorMessageId = "headerLineMismatchAtPos";
-                                const columnOffset = i === 0 ? "/*".length : 0;
-                                assertDefined(firstLeadingCommentLoc);
-                                assertNotNull(firstLeadingCommentLoc);
-                                const line = firstLeadingCommentLoc.start.line + i;
-                                errorMessageLoc = {
-                                    start: {
-                                        column: columnOffset + j,
-                                        line
-                                    },
-                                    end: {
-                                        column: columnOffset + leadingLine.length,
-                                        line
-                                    }
-                                };
-                                errorMessageData = {
-                                    expected: headerLine.substring(j)
-                                };
-                                break;
-                            }
-                        }
-                        if (errorMessageId) {
-                            break;
-                        }
-                        if (leadingLine.length < headerLine.length) {
-                            errorMessageId = "headerLineTooShort";
-                            const startColumn = (i === 0 ? "/*".length : 0) + leadingLine.length;
-                            assertDefined(firstLeadingCommentLoc);
-                            assertNotNull(firstLeadingCommentLoc);
-                            errorMessageLoc = {
-                                start: {
-                                    column: startColumn,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                },
-                                end: {
-                                    column: startColumn + 1,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                }
-                            };
-                            errorMessageData = {
-                                remainder: headerLine.substring(leadingLine.length)
-                            };
-                            break;
-                        }
-                        if (leadingLine.length > headerLine.length) {
-                            assertDefined(firstLeadingCommentLoc);
-                            assertNotNull(firstLeadingCommentLoc);
-                            errorMessageId = "headerLineTooLong";
-                            errorMessageLoc = {
-                                start: {
-                                    column: (i === 0 ? "/*".length : 0) + headerLine.length,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                },
-                                end: {
-                                    column: (i === 0 ? "/*".length : 0) + leadingLine.length,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                }
-                            };
-                            break;
-                        }
-                    } else {
-                        if (!match(leadingLine, headerLine)) {
-                            errorMessageId = "incorrectHeaderLine";
-                            errorMessageData = {
-                                pattern: headerLine.toString()
-                            };
-                            const columnOffset = i === 0 ? "/*".length : 0;
-                            assertDefined(firstLeadingCommentLoc);
-                            assertNotNull(firstLeadingCommentLoc);
-                            errorMessageLoc = {
-                                start: {
-                                    column: columnOffset + 0,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                },
-                                end: {
-                                    column: columnOffset + leadingLine.length,
-                                    line: firstLeadingCommentLoc.start.line + i
-                                }
-                            };
-                            break;
-                        }
-                    }
-                }
-
-                if (!errorMessageId && leadingLines.length > headerLines.length) {
-                    errorMessageId = "headerTooLong";
-                    assertDefined(firstLeadingCommentLoc);
-                    assertNotNull(firstLeadingCommentLoc);
-                    assertDefined(lastLeadingCommentLoc);
-                    assertNotNull(lastLeadingCommentLoc);
-                    errorMessageLoc = {
-                        start: {
-                            column: (headerLines.length === 0 ? "/*".length : 0) + 0,
-                            line: firstLeadingCommentLoc.start.line + headerLines.length
-                        },
-                        end: {
-                            column: lastLeadingCommentLoc.end.column - "*/".length,
-                            line: lastLeadingCommentLoc.end.line
-                        }
-                    };
-                }
-
-                if (errorMessageId) {
-                    if (canFix && headerLines.length > 1) {
-                        fixLines = [fixLines.join(eol)];
+                const leadingComments = getLeadingComments(sourceCode);
+
+                const report = headerMatcher.validate(leadingComments, sourceCode);
+
+                if (report !== null) {
+                    if ("messageId" in report && report.messageId === "noNewlineAfterHeader") {
+                        const { expected, actual } =
+                            /** @type {{ expected: number, actual: number }} */ (report.data);
+                        report.fix = genEmptyLinesFixer(leadingComments, eol, expected - actual);
+                    } else if (canFix) {
+                        report.fix = genReplaceFixer(
+                            headerMatcher.commentType,
+                            sourceCode,
+                            leadingComments,
+                            fixLines,
+                            eol,
+                            numLines);
                     }
-                    assertNotNull(errorMessageLoc);
-                    context.report({
-                        loc: errorMessageLoc,
-                        messageId: errorMessageId,
-                        data: errorMessageData,
-                        fix: canFix
-                            ? genReplaceFixer(
-                                commentType,
-                                context,
-                                leadingComments,
-                                fixLines,
-                                eol,
-                                numLines)
-                            : null
-                    });
-                    return;
-                }
-
-                const actualLeadingEmptyLines =
-                    leadingEmptyLines(sourceCode.text.substring(firstLeadingCommentRange[1]));
-                const missingEmptyLines = numLines - actualLeadingEmptyLines;
-                if (missingEmptyLines > 0) {
-                    context.report({
-                        loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
-                        messageId: "noNewlineAfterHeader",
-                        data: {
-                            expected: numLines,
-                            actual: actualLeadingEmptyLines
-                        },
-                        fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
-                    });
+                    context.report(report);
                 }
             }
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tony.ganchev/eslint-plugin-header",
-  "version": "3.2.5",
+  "version": "3.2.6",
   "description": "The native ESLint 9/10 header plugin. A zero-bloat, drop-in replacement for 'eslint-plugin-header' with first-class Flat Config & TypeScript support. Auto-fix Copyright, License, and banner comments in JavaScrip and TypeScript files.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -18,19 +18,20 @@
     "CONTRIBUTING.md"
   ],
   "devDependencies": {
+    "@eslint/core": "^1.1.1",
     "@eslint/js": "^10.0.1",
     "@eslint/markdown": "^7.5.1",
-    "@stylistic/eslint-plugin": "^5.9.0",
+    "@stylistic/eslint-plugin": "^5.10.0",
     "@types/estree": "^1.0.8",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^25.3.0",
-    "c8": "^10.1.3",
-    "eslint": "^10.0.2",
-    "eslint-plugin-eslint-plugin": "^7.3.1",
+    "@types/node": "^25.3.5",
+    "c8": "^11.0.0",
+    "eslint": "^10.0.3",
+    "eslint-plugin-eslint-plugin": "^7.3.2",
     "eslint-plugin-jsdoc": "^62.7.1",
     "eslint-plugin-n": "^17.24.0",
-    "globals": "^17.3.0",
-    "markdownlint-cli": "^0.47.0",
+    "globals": "^17.4.0",
+    "markdownlint-cli": "^0.48.0",
     "mocha": "12.0.0-beta-9",
     "testdouble": "^3.20.2",
     "typescript": "^5.9.3",

package/types/lib/rules/header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../../lib/rules/header.js"],"names":[],"mappings":";2BAqCa,iBAAiB;0BACjB,gBAAgB;wBAChB,cAAc;0BACd,gBAAgB;;;;;yBAIhB,IAAI,GAAG,MAAM;;;;;;;;;;aAOZ,MAAM,GAAG,MAAM;;;;;;;;;;;;yBAOhB,MAAM,GAAG,MAAM,GAAG,iBAAiB;;;;;0BAGnC,UAAU,GAAG,UAAU,EAAE;;;;;;+BAEzB,IAAI,GAAG,MAAM,GAAG,SAAS;;;;;6BAGzB;IAAE,WAAW,CAAC,EAAE,gBAAgB,CAAA;CAAE;;;;;0BAElC,OAAO,GAAG,MAAM;;;;;;;;;;UAOf,MAAM;;;;;;;;;;;;;;;iBASN,WAAW;;;;;;WACX,UAAU,EAAE;;;;;;;;;;;;;;;;;;YAcZ,eAAe,GAAG,YAAY;;;;;;;;;;;4BAO/B,4BAA4B,GAAG,cAAc;oCAK7C,CAAC,QAAQ,EAAE,MAAM,CAAC;4CAClB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC;iCAE5C,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,CAAC;yCACvC,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,cAAc,CAAC;yCAEjE,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,CAAC;iDAEzD,CACV,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,cAAc,CACvB;;;;+BACS,CAAC,aAAa,CAAC,GACvB,qBAAqB,GACrB,6BAA6B,GAC7B,kBAAkB,GAClB,0BAA0B,GAC1B,0BAA0B,GAC1B,kCAAkC;;;;;+BAK1B,iBAAiB,gBAAgB,CAAC;AAqb/C,8BAA8B;AAC9B,0BADW,eAAe,CAufxB;0BAjhC+B,QAAQ;4BAAR,QAAQ"}
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../../lib/rules/header.js"],"names":[],"mappings":";2BAsCa,iBAAiB;0BACjB,gBAAgB;wBAChB,cAAc;0BACd,gBAAgB;;;;;yBAIhB,IAAI,GAAG,MAAM;;;;;;;;;;aAOZ,MAAM,GAAG,MAAM;;;;;;;;;;;;yBAOhB,MAAM,GAAG,MAAM,GAAG,iBAAiB;;;;;0BAGnC,UAAU,GAAG,UAAU,EAAE;;;;;;+BAEzB,IAAI,GAAG,MAAM,GAAG,SAAS;;;;;6BAGzB;IAAE,WAAW,CAAC,EAAE,gBAAgB,CAAA;CAAE;;;;;0BAElC,OAAO,GAAG,MAAM;;;;;;;;;;UAOf,MAAM;;;;;;;;;;;;;;;iBASN,WAAW;;;;;;WACX,UAAU,EAAE;;;;;;;;;;;;;;;;;;YAcZ,eAAe,GAAG,YAAY;;;;;;;;;;;4BAO/B,4BAA4B,GAAG,cAAc;oCAK7C,CAAC,QAAQ,EAAE,MAAM,CAAC;4CAClB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC;iCAE5C,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,CAAC;yCACvC,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,cAAc,CAAC;yCAEjE,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,CAAC;iDAEzD,CACV,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,cAAc,CACvB;;;;+BACS,CAAC,aAAa,CAAC,GACvB,qBAAqB,GACrB,6BAA6B,GAC7B,kBAAkB,GAClB,0BAA0B,GAC1B,0BAA0B,GAC1B,kCAAkC;;;;;+BAK1B,iBAAiB,gBAAgB,CAAC;AA0sB/C,8BAA8B;AAC9B,0BADW,eAAe,CAuHxB;0BAv6B4D,QAAQ;4BAAR,QAAQ"}