eslint-plugin-imports-regulation 0.2.6 → 0.2.8

package/dist/rules/imports-regulation.js

@@ -65,7 +65,7 @@ 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}}.',
             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`.',
@@ -151,17 +151,75 @@ const rule = {
                 return undefined;
             return [open.range[1], close.range[0]];
         };
-        /** Re-join specifiers in the shape the braces already had, so a multi-line import stays one. */
-        const rejoin = (range, texts) => {
+        /**
+         * The comments inside the braces, shared out between the specifiers. An own-line one precedes
+         * the specifier it describes, a same-line one trails it, and any left before the closing brace
+         * stay last.
+         */
+        const commentsInBraces = (named, range) => {
+            const carried = new Map();
+            for (const specifier of named)
+                carried.set(specifier, { leading: [], beforeComma: [], afterComma: [] });
+            const tail = [];
+            for (const comment of source.getAllComments()) {
+                if (comment.range[0] < range[0] || comment.range[1] > range[1])
+                    continue;
+                const text = source.text.slice(comment.range[0], comment.range[1]);
+                const nextIndex = named.findIndex(specifier => specifier.range[0] >= comment.range[1]);
+                const next = nextIndex === -1 ? undefined : named[nextIndex];
+                const previous = named[(nextIndex === -1 ? named.length : nextIndex) - 1];
+                if (!previous) {
+                    if (next)
+                        carried.get(next)?.leading.push(text);
+                    continue;
+                }
+                const after = source.getTokenAfter(previous);
+                const comma = after?.value === ',' ? after : undefined;
+                const own = carried.get(previous);
+                if (comma && comment.range[1] <= comma.range[0])
+                    own?.beforeComma.push(text);
+                else if (comment.loc.start.line === (comma ?? previous).loc.end.line
+                    && (!next || next.loc.start.line > comment.loc.end.line))
+                    own?.afterComma.push(text);
+                else if (next)
+                    carried.get(next)?.leading.push(text);
+                else
+                    tail.push(text);
+            }
+            return { carried, tail };
+        };
+        /** Re-join specifiers in the shape the braces already had, carrying their comments with them. */
+        const rejoin = (range, named, ordered, textOf) => {
             const interior = source.text.slice(range[0], range[1]);
+            const { carried, tail } = commentsInBraces(named, range);
+            const pieceOf = (specifier) => carried.get(specifier) ?? { leading: [], beforeComma: [], afterComma: [] };
             if (!BREAK.test(interior)) {
+                // Only block comments fit on one line, so a trailing one can always sit before the comma.
                 const pad = /^\s/.test(interior) ? ' ' : '';
-                return `${pad}${texts.join(', ')}${pad}`;
+                const parts = ordered.map(specifier => {
+                    const { leading, beforeComma, afterComma } = pieceOf(specifier);
+                    return [...leading, textOf(specifier), ...beforeComma, ...afterComma].join(' ');
+                });
+                return `${pad}${parts.join(', ')}${tail.map(comment => ` ${comment}`).join('')}${pad}`;
             }
             const indent = /(?:\r\n|\n|\r)([^\S\r\n]*)\S/.exec(interior)?.[1] ?? '    ';
             const closeIndent = /(?:\r\n|\n|\r)([^\S\r\n]*)$/.exec(interior)?.[1] ?? '';
-            const comma = /,\s*$/.test(interior) ? ',' : '';
-            return `${eol}${indent}${texts.join(`,${eol}${indent}`)}${comma}${eol}${closeIndent}`;
+            // From the tokens, not the text: a comment after the last comma hides it from a regex.
+            const last = named[named.length - 1];
+            const trailingComma = last !== undefined && source.getTokenAfter(last)?.value === ',';
+            const lines = [];
+            for (const [index, specifier] of ordered.entries()) {
+                const { leading, beforeComma, afterComma } = pieceOf(specifier);
+                for (const comment of leading)
+                    lines.push(`${indent}${comment}`);
+                const comma = index < ordered.length - 1 || trailingComma ? ',' : '';
+                // After the comma, since a line comment before it would swallow it.
+                const trailing = afterComma.map(comment => ` ${comment}`).join('');
+                lines.push(`${indent}${[textOf(specifier), ...beforeComma].join(' ')}${comma}${trailing}`);
+            }
+            for (const comment of tail)
+                lines.push(`${indent}${comment}`);
+            return `${eol}${lines.join(eol)}${eol}${closeIndent}`;
         };
         const asValueSpecifier = (specifier) => {
             const imported = source.getText(specifier.imported);
@@ -211,7 +269,7 @@ const rule = {
                         const fixes = [fixer.insertTextAfter(keyword, ' type')];
                         // An inline marker is redundant under `import type`, and illegal besides.
                         if (range && named.some(specifier => specifier.importKind === 'type')) {
-                            fixes.push(fixer.replaceTextRange(range, rejoin(range, named.map(asValueSpecifier))));
+                            fixes.push(fixer.replaceTextRange(range, rejoin(range, named, named, asValueSpecifier)));
                         }
                         return fixes;
                     },
@@ -251,7 +309,7 @@ const rule = {
                     messageId: 'markTypeOnly',
                     fix: fixer => [
                         fixer.insertTextAfter(keyword, ' type'),
-                        fixer.replaceTextRange(range, rejoin(range, named.map(asValueSpecifier))),
+                        fixer.replaceTextRange(range, rejoin(range, named, named, asValueSpecifier)),
                     ],
                 });
                 return;
@@ -273,17 +331,31 @@ const rule = {
             context.report({
                 node: misplaced,
                 messageId: 'typeSpecifiersLast',
-                fix: fixer => fixer.replaceTextRange(range, rejoin(range, [...values, ...types].map(specifier => source.getText(specifier)))),
+                fix: fixer => fixer.replaceTextRange(range, rejoin(range, named, [...values, ...types], specifier => source.getText(specifier))),
             });
         };
+        /** Comments that mean something only where they are, so they never move with an import. */
+        const staysPut = (comment) => {
+            if (source.text.startsWith('#!', comment.range[0]))
+                return true;
+            if (comment.type === 'Line' && comment.value.startsWith('/'))
+                return true; // `/// <reference>`
+            if (comment.type === 'Block' && comment.value.startsWith('!'))
+                return true; // `/*! licence */`
+            const text = comment.value.replace(/^\*+/, '').trim();
+            // Region and file directives. `eslint-disable-next-line` and `@ts-expect-error` are about
+            // the next line, so those do move with it.
+            return /^(?:eslint-(?:disable|enable)(?![-\w])|eslint(?:-env)?\s|globals?\s|exported\s|@ts-(?:no)?check\b|@jsx|@license|@preserve)/
+                .test(text);
+        };
         /** An import plus the comments that travel with it. */
         const entriesOf = (chunk) => {
             const entries = [];
             for (const node of chunk) {
                 const previous = entries[entries.length - 1];
                 let start = node.range[0];
-                // An own-line comment belongs to the import beneath it. One above the *first* import of
-                // a chunk is left where it is, being as likely a file header as a note about the import.
+                // Comments precede what they describe, so an own-line comment belongs to the import
+                // beneath it.
                 if (previous) {
                     for (const comment of source.getCommentsBefore(node)) {
                         if (comment.range[0] >= previous.end) {
@@ -292,10 +364,27 @@ const rule = {
                         }
                     }
                 }
+                else {
+                    // Above the first import only the comments directly on it: a blank line makes the
+                    // rest a file header.
+                    let below = node.loc.start.line;
+                    const before = source.getCommentsBefore(node);
+                    for (let i = before.length - 1; i >= 0; i--) {
+                        const comment = before[i];
+                        if (!comment || comment.loc.end.line < below - 1 || staysPut(comment))
+                            break;
+                        start = comment.range[0];
+                        below = comment.loc.start.line;
+                    }
+                }
+                // Every comment on the import's last line, not just the first: a second one there is
+                // not a note on the next import.
                 let end = node.range[1];
-                const trailing = source.getCommentsAfter(node)[0];
-                if (trailing && trailing.loc.start.line === node.loc.end.line)
-                    end = trailing.range[1];
+                for (const comment of source.getCommentsAfter(node)) {
+                    if (comment.loc.start.line !== node.loc.end.line)
+                        break;
+                    end = comment.range[1];
+                }
                 entries.push({ node, group: groupOf(node), start, end });
             }
             return entries;
@@ -397,6 +486,8 @@ const rule = {
                 const wanted = boundary ? blankLinesBetween : 0;
                 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,
@@ -406,9 +497,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.6",
+  "version": "0.2.8",
   "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",