eslint-plugin-imports-regulation 0.2.13 → 0.2.15

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

@@ -1,5 +1,5 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-type MessageIds = 'groupOrder' | 'exportBlock' | 'blankLinesBetween' | 'unexpectedBlankLine' | 'blankLineBelowComment' | 'typeSpecifiersLast' | 'typeSpecifiersFirst' | 'markTypeOnly' | 'typeOnlyImport' | 'typeOnlySpecifier' | 'blankLinesAfter' | 'multilineBraces';
+type MessageIds = 'groupOrder' | 'exportBlock' | 'blankLinesBetween' | 'unexpectedBlankLine' | 'blankLineBelowComment' | 'typeSpecifiersLast' | 'typeSpecifiersFirst' | 'markTypeOnly' | 'typeOnlyImport' | 'typeOnlySpecifier' | 'blankLinesAfter' | 'multilineBraces' | 'codeAmongImports';
 type Origin = 'external' | 'internal';
 type Options = [
     {
@@ -13,6 +13,7 @@ type Options = [
         importsAddenda?: string[];
         preferTypeDeclarations?: boolean;
         inferTypeOnlyImports?: boolean;
+        maxLen?: number;
     }?
 ];
 declare const rule: TSESLint.RuleModule<MessageIds, Options>;

package/dist/rules/imports-regulation.js

@@ -1,5 +1,7 @@
 const DEFAULT_BLANK_LINES_BETWEEN = 1;
 const DEFAULT_BLANK_LINES_AFTER = 2;
+// A rule cannot read `max-len`'s options, so this is its default.
+const DEFAULT_MAX_LEN = 80;
 // The order, as written. The blank line falls between 1 and 2 — nowhere else.
 const EXTERNAL_TYPE = 0;
 const INTERNAL_TYPE = 2;
@@ -58,6 +60,8 @@ const rule = {
                     preferTypeDeclarations: { type: 'boolean' },
                     // Mark bindings that scope analysis shows are only ever used in type positions.
                     inferTypeOnlyImports: { type: 'boolean' },
+                    // The longest line a fix may write when it gathers names; lines as written are left alone.
+                    maxLen: { type: 'integer', minimum: 1 },
                 },
                 additionalProperties: false,
             },
@@ -74,6 +78,7 @@ const rule = {
             typeOnlyImport: 'Everything this imports is only used as a type — write `import type`.',
             typeOnlySpecifier: '`{{name}}` is only used as a type — mark it `type`.',
             blankLinesAfter: 'Expected {{expected}} blank {{lines}} after the imports, found {{actual}}.',
+            codeAmongImports: 'Expected no code among the imports.',
             multilineBraces: 'Expected a multiline {{kind}} to end a line with `{` and start one with `}{{tail}}`.',
         },
     },
@@ -90,6 +95,7 @@ const rule = {
         const addenda = (options?.importsAddenda ?? []).map(lineGlobToRegExp);
         const preferTypeDeclarations = options?.preferTypeDeclarations ?? true;
         const inferTypeOnlyImports = options?.inferTypeOnlyImports ?? true;
+        const maxLen = options?.maxLen ?? DEFAULT_MAX_LEN;
         const eol = BREAK.exec(source.text)?.[0] ?? '\n';
         const originOf = (path) => {
             for (const { test, group } of patterns)
@@ -352,8 +358,7 @@ const rule = {
                             return fixer.replaceTextRange(range, rejoin(range, named, [...types, ...values], specifier => source.getText(specifier)));
                         }
                         const { indent, closeIndent, trailingComma } = shapeOf(range, named);
-                        const line = (group) => `${indent}${group.map(specifier => source.getText(specifier)).join(', ')}`;
-                        const text = `${line(types)},${eol}${line(values)}${trailingComma ? ',' : ''}`;
+                        const text = stacked(named, indent, trailingComma).join(eol);
                         return fixer.replaceTextRange(range, `${eol}${text}${eol}${closeIndent}`);
                     },
                 });
@@ -369,6 +374,31 @@ const rule = {
                 fix: fixer => fixer.replaceTextRange(range, rejoin(range, named, [...values, ...types], specifier => source.getText(specifier))),
             });
         };
+        const isTypeSpecifier = (specifier) => (specifier.type === 'ImportSpecifier' ? specifier.importKind : specifier.exportKind) === 'type';
+        /** Names packed greedily into lines within `maxLen`, every line but the last ending in a comma. */
+        const pack = (specifiers, indent, comma) => {
+            const lines = [];
+            let line = '';
+            for (const specifier of specifiers) {
+                const text = source.getText(specifier);
+                const joined = line ? `${line}, ${text}` : text;
+                if (line && indent.length + joined.length + 1 > maxLen) {
+                    lines.push(line);
+                    line = text;
+                }
+                else
+                    line = joined;
+            }
+            if (line)
+                lines.push(line);
+            return lines.map((text, i) => `${indent}${text}${i < lines.length - 1 || comma ? ',' : ''}`);
+        };
+        /** Types' lines above the values', since a line holding both would read as one list. */
+        const stacked = (specifiers, indent, trailingComma) => {
+            const types = specifiers.filter(isTypeSpecifier);
+            const values = specifiers.filter(specifier => !isTypeSpecifier(specifier));
+            return [...pack(types, indent, values.length > 0 || trailingComma), ...pack(values, indent, trailingComma)];
+        };
         const checkBraces = (node, specifiers) => {
             const first = specifiers[0];
             const last = specifiers[specifiers.length - 1];
@@ -418,6 +448,20 @@ const rule = {
                 },
             });
         };
+        // Matched by its name after the plugin prefix, which differs by config.
+        const ruleName = context.id.split('/').pop() ?? context.id;
+        /** This rule is disabled on the statement's last line. */
+        const passedOver = (statement) => source.getCommentsAfter(statement).some(comment => {
+            if (comment.loc.start.line !== statement.loc.end.line)
+                return false;
+            const directive = /^eslint-disable-line(?:\s+([^]*?))?(?:\s--[^]*)?$/.exec(comment.value.trim());
+            if (!directive)
+                return false;
+            const rules = directive[1]?.split(',').map(rule => rule.trim()).filter(Boolean) ?? [];
+            return rules.length === 0 || rules.some(rule => rule === ruleName || rule.endsWith(`/${ruleName}`));
+        });
+        // Passed-over statements, by the header statement they follow and travel with.
+        const attached = new Map();
         /** `export … from` and `export { … }`, which sit among the imports; a declaration is code. */
         const isHeaderExport = (node) => node.type === 'ExportAllDeclaration' || (node.type === 'ExportNamedDeclaration' && node.declaration === null);
         /** Comments that mean something only where they are, so they never move with an import. */
@@ -465,9 +509,10 @@ const rule = {
                 }
                 // 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];
-                for (const comment of source.getCommentsAfter(node)) {
-                    if (comment.loc.start.line !== node.loc.end.line)
+                const tail = attached.get(node) ?? node;
+                let end = tail.range[1];
+                for (const comment of source.getCommentsAfter(tail)) {
+                    if (comment.loc.start.line !== tail.loc.end.line)
                         break;
                     end = comment.range[1];
                 }
@@ -750,14 +795,32 @@ const rule = {
                         checkChunk(chunk, chunk[0] === program.body[0]);
                     chunk = [];
                 };
-                for (const statement of program.body) {
+                const isHeader = (statement) => statement !== undefined && (statement.type === 'ImportDeclaration' || isHeaderExport(statement));
+                const body = program.body;
+                for (let i = 0; i < body.length; i++) {
+                    const statement = body[i];
                     // A bare `import 'x'` sorts like any other — where its side effect has to run in a
                     // particular place, that is what a disable comment is for. Anything that is not an
                     // import or re-export does end the run, since moving code across it could change what happens.
-                    if (statement.type === 'ImportDeclaration' || isHeaderExport(statement))
+                    if (isHeader(statement)) {
                         chunk.push(statement);
-                    else
-                        flush();
+                        continue;
+                    }
+                    // Unless this rule is disabled on its line and imports carry on after it: then it goes with the import above.
+                    let j = i;
+                    for (let next = body[j]; next && !isHeader(next) && passedOver(next); next = body[j])
+                        j++;
+                    const above = chunk[chunk.length - 1];
+                    const last = body[j - 1];
+                    if (above && last && j > i && isHeader(body[j])) {
+                        attached.set(above, last);
+                        // Suppressed by the directive, and what keeps it in use: unused, `--fix` would delete it.
+                        for (const passed of body.slice(i, j))
+                            context.report({ node: passed, messageId: 'codeAmongImports' });
+                        i = j - 1;
+                        continue;
+                    }
+                    flush();
                 }
                 flush();
             },

package/package.json

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