eslint-plugin-imports-regulation 0.2.8 → 0.2.10

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

@@ -66,6 +66,7 @@ const rule = {
             groupOrder: 'Expected this {{group}} import before the {{other}} imports.',
             blankLinesBetween: 'Expected {{expected}} blank {{lines}} between external imports and internal imports, found {{actual}}.',
             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`.',
@@ -242,7 +243,9 @@ const rule = {
             for (const variable of source.getDeclaredVariables(node)) {
                 if (variable.references.length === 0)
                     continue;
-                if (variable.references.every(reference => reference.isTypeReference))
+                // A plain `export { x }` is flagged as both, and could be a value.
+                const typeOnly = variable.references.every(reference => reference.isTypeReference && !reference.isValueReference);
+                if (typeOnly)
                     names.add(variable.name);
             }
             return names;
@@ -389,6 +392,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() === '';
         /**
@@ -438,13 +467,15 @@ const rule = {
                 fix: fixer => fixer.replaceTextRange([from, to], eol.repeat(blankLinesAfter + 1)),
             });
         };
-        const checkChunk = (chunk) => {
+        const checkChunk = (chunk, leading) => {
             const entries = entriesOf(chunk);
             const first = entries[0];
             const last = entries[entries.length - 1];
             if (!first || !last)
                 return;
-            checkAfterImports(last);
+            // An import after code is not the imports block, so no gap is owed after it.
+            if (leading)
+                checkAfterImports(last);
             if (entries.length < 2)
                 return;
             const rewrite = fixer => {
@@ -457,7 +488,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,6 +515,15 @@ 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
@@ -512,7 +552,7 @@ const rule = {
                 let chunk = [];
                 const flush = () => {
                     if (chunk.length > 0)
-                        checkChunk(chunk);
+                        checkChunk(chunk, chunk[0] === program.body[0]);
                     chunk = [];
                 };
                 for (const statement of program.body) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-imports-regulation",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "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",