eslint-plugin-imports-regulation 0.2.7 → 0.2.9

package/dist/rules/imports-regulation.d.ts

@@ -1,5 +1,5 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-type MessageIds = 'groupOrder' | 'blankLinesBetween' | 'unexpectedBlankLine' | 'typeSpecifiersLast' | 'markTypeOnly' | 'typeOnlyImport' | 'typeOnlySpecifier' | 'blankLinesAfter';
+type MessageIds = 'groupOrder' | 'blankLinesBetween' | 'unexpectedBlankLine' | 'blankLineBelowComment' | 'typeSpecifiersLast' | 'markTypeOnly' | 'typeOnlyImport' | 'typeOnlySpecifier' | 'blankLinesAfter';
 type Origin = 'external' | 'internal';
 type Options = [
     {

package/dist/rules/imports-regulation.js

@@ -65,7 +65,8 @@ const rule = {
         messages: {
             groupOrder: 'Expected this {{group}} import before the {{other}} imports.',
             blankLinesBetween: 'Expected {{expected}} blank {{lines}} between external imports and internal imports, found {{actual}}.',
-            unexpectedBlankLine: 'Unexpected blank line between imports in the same group.',
+            unexpectedBlankLine: 'Expected no blank lines between imports in the same group, found {{actual}}.',
+            blankLineBelowComment: 'Expected no blank lines between a comment and the import it belongs to, found {{actual}}.',
             typeSpecifiersLast: 'Type specifiers must come after value specifiers.',
             markTypeOnly: 'An import of nothing but types must be written `import type { A }`.',
             typeOnlyImport: 'Everything this imports is only used as a type — write `import type`.',
@@ -389,6 +390,32 @@ const rule = {
             }
             return entries;
         };
+        /**
+         * An entry's text with the blank lines below its comments taken out, and how many there were.
+         * Only the whitespace between comments is looked at: a blank line inside a block comment is
+         * the comment's own.
+         */
+        const tightened = (entry) => {
+            let blank = 0;
+            let text = '';
+            let cursor = entry.start;
+            const closeGap = (to) => {
+                const gap = source.text.slice(cursor, to);
+                const breaks = (gap.match(BREAK_GLOBAL) ?? []).length;
+                blank += Math.max(breaks - 1, 0);
+                text += breaks > 1 ? `${eol}${/[^\r\n]*$/.exec(gap)?.[0] ?? ''}` : gap;
+            };
+            for (const comment of source.getAllComments()) {
+                if (comment.range[0] < entry.start || comment.range[1] > entry.node.range[0])
+                    continue;
+                closeGap(comment.range[0]);
+                text += source.text.slice(comment.range[0], comment.range[1]);
+                cursor = comment.range[1];
+            }
+            closeGap(entry.node.range[0]);
+            text += source.text.slice(entry.node.range[0], entry.end);
+            return { blank, text };
+        };
         const lineAt = (index) => source.lines[index] ?? '';
         const isBlank = (index) => lineAt(index).trim() === '';
         /**
@@ -457,7 +484,7 @@ const rule = {
                         const boundary = isInternalGroup(entry.group) !== isInternalGroup(previous.group);
                         text += eol.repeat(boundary ? blankLinesBetween + 1 : 1);
                     }
-                    text += source.text.slice(entry.start, entry.end);
+                    text += tightened(entry).text;
                     previous = entry;
                 }
                 return fixer.replaceTextRange([first.start, last.end], text);
@@ -484,8 +511,19 @@ const rule = {
                 const blank = Math.max((gap.match(BREAK_GLOBAL) ?? []).length - 1, 0);
                 const boundary = isInternalGroup(entry.group) !== isInternalGroup(previous.group);
                 const wanted = boundary ? blankLinesBetween : 0;
+                const below = tightened(entry).blank;
+                if (below > 0) {
+                    context.report({
+                        node: entry.node,
+                        messageId: 'blankLineBelowComment',
+                        data: { actual: String(below) },
+                        fix: rewrite,
+                    });
+                }
                 if (blank === wanted)
                     continue;
+                // Every gap, each with the whole-run fix: ESLint applies one, and the rest are gone on
+                // the next pass.
                 if (boundary) {
                     context.report({
                         node: entry.node,
@@ -495,9 +533,13 @@ const rule = {
                     });
                 }
                 else {
-                    context.report({ node: entry.node, messageId: 'unexpectedBlankLine', fix: rewrite });
+                    context.report({
+                        node: entry.node,
+                        messageId: 'unexpectedBlankLine',
+                        data: { actual: String(blank) },
+                        fix: rewrite,
+                    });
                 }
-                return;
             }
         };
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-imports-regulation",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Order imports: external type-only, external, blank line, internal type-only, internal — with type specifiers last inside each import.",
   "author": "Robert Sandiford",
   "type": "module",