eslint-plugin-imports-regulation 0.2.13 → 0.2.14

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

@@ -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,
             },
@@ -90,6 +94,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 +357,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 +373,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];

package/package.json

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