eslint-plugin-imports-regulation 0.2.16 → 0.2.17

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' | 'codeAmongImports' | 'manageLineLength' | 'exportsBlockGap' | 'exportsBlockSpacing';
+type MessageIds = 'groupOrder' | 'exportBlock' | 'blankLinesBetween' | 'unexpectedBlankLine' | 'blankLineBelowComment' | 'typeSpecifiersLast' | 'typeSpecifiersFirst' | 'markTypeOnly' | 'typeOnlyImport' | 'typeOnlySpecifier' | 'blankLinesAfter' | 'multilineBraces' | 'codeAmongImports' | 'namesFitOneLine' | 'nameLineTooLong' | 'nameFitsAbove' | 'exportsBlockGap' | 'exportsBlockSpacing';
 type Origin = 'external' | 'internal';
 type Options = [
     {

package/dist/rules/imports-regulation.js

@@ -82,7 +82,9 @@ const rule = {
             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.',
-            manageLineLength: 'Expected these names to fill the line, within {{maxLen}} characters.',
+            namesFitOneLine: 'This import fits on one line.',
+            nameLineTooLong: 'This name runs the line past {{maxLen}} characters.',
+            nameFitsAbove: 'This name fits on the line above.',
             exportsBlockGap: 'Expected at most {{expected}} blank {{lines}} before the exports block, found {{actual}}.',
             exportsBlockSpacing: 'Expected at most {{expected}} blank {{lines}} between the exports, found {{actual}}.',
             multilineBraces: 'Expected a multiline {{kind}} to end a line with `{` and start one with `}{{tail}}`.',
@@ -219,14 +221,23 @@ const rule = {
             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)) {
+            // The names' own lines, not the braces': names on one line stay on one line, whether or
+            // not the braces sit on lines of their own.
+            const first = named[0];
+            const last = named[named.length - 1];
+            const oneLine = first !== undefined && last !== undefined && first.loc.start.line === last.loc.end.line;
+            if (oneLine) {
                 // Only block comments fit on one line, so a trailing one can always sit before the comma.
-                const pad = /^\s/.test(interior) ? ' ' : '';
+                const pad = BREAK.test(interior) ? '' : /^\s/.test(interior) ? ' ' : '';
                 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 names = `${parts.join(', ')}${tail.map(comment => ` ${comment}`).join('')}`;
+                if (!BREAK.test(interior))
+                    return `${pad}${names}${pad}`;
+                const { indent, closeIndent, trailingComma } = shapeOf(range, named);
+                return `${eol}${indent}${names}${trailingComma ? ',' : ''}${eol}${closeIndent}`;
             }
             const { indent, closeIndent, trailingComma } = shapeOf(range, named);
             const lines = [];
@@ -409,56 +420,138 @@ const rule = {
         /** Whitespace runs closed up, so a statement spread over lines can be measured as one. */
         const flattened = (text) => text.replace(/\s*(?:\r\n|\n|\r)\s*/g, ' ');
         /**
-         * The names filled to `maxLen`: one line if the whole statement fits, else stacked.
+         * The line length, as three faults with a fix each: a statement spread over lines that would
+         * fit on one, a line of names past the limit, and a name that would fit on the line above.
          *
-         * The whole statement, not the names alone, since what is owed is a line within the limit —
-         * and what sits outside the braces (`import type {`, `} from '…'`) is part of that line.
+         * Each fix moves one break, leaving everything else as written — the order, the trailing
+         * comma and the spacing are other checks' business.
          */
-        const checkPacking = (node, specifiers, open, close) => {
+        const checkLineLength = (node, specifiers, open, close) => {
             if (specifiers.length === 0)
                 return false;
             const interior = [open.range[1], close.range[0]];
-            // Rebuilt from the specifiers alone, so a comment among them would be dropped; attributes
-            // bring braces of their own, which flattening would mangle.
+            // A comment among the names has a line of its own to be on, and moving names across it
+            // would change what it describes; attributes bring braces that flattening would mangle.
             if (source.getAllComments().some(c => c.range[0] >= interior[0] && c.range[1] <= interior[1]))
                 return false;
             if (node.type === 'ImportDeclaration' && node.attributes.length > 0)
                 return false;
+            const written = source.getText(node);
             const base = /^[^\S\r\n]*/.exec(lineAt(node.loc.start.line - 1))?.[0] ?? '';
-            const prefix = flattened(source.text.slice(node.range[0], open.range[1]));
-            const suffix = flattened(source.text.slice(close.range[0], node.range[1]));
-            const ordered = [
-                ...specifiers.filter(specifier => !isTypeSpecifier(specifier)),
-                ...specifiers.filter(isTypeSpecifier),
-            ];
-            const names = ordered.map(specifier => source.getText(specifier)).join(', ');
-            const oneLine = `${base}${prefix} ${names} ${suffix}`;
-            let wanted;
-            if (oneLine.length <= maxLen)
-                wanted = oneLine;
-            else {
-                const { indent } = source.text.slice(...interior).includes(eol)
-                    ? shapeOf(interior, specifiers)
-                    : { indent: `${base}    ` };
-                const lines = stacked(specifiers, indent, true);
-                wanted = `${base}${prefix}${eol}${lines.join(eol)}${eol}${base}${suffix}`;
-                // Breaking up a single line that is over the limit whatever is done to it gains nothing,
-                // and would be reported for ever. Filling lines makes them longer, which is the point.
-                const longest = (text) => Math.max(...text.split(BREAK_GLOBAL).map(line => line.length));
-                const written = `${base}${source.getText(node)}`;
-                if (!BREAK.test(written) && longest(wanted) >= longest(written))
+            // On one line a trailing comma is a dangling one, so it goes with the break it belonged to.
+            const flat = flattened(written).replace(/,(\s*})/, '$1');
+            if (BREAK.test(written) && base.length + flat.length <= maxLen) {
+                context.report({
+                    node,
+                    messageId: 'namesFitOneLine',
+                    fix: fixer => fixer.replaceTextRange(node.range, flat),
+                });
+                return true;
+            }
+            // The names as they are laid out, a run to each line.
+            const rows = [];
+            for (const specifier of specifiers) {
+                const row = rows[rows.length - 1];
+                if (row?.[row.length - 1]?.loc.end.line === specifier.loc.start.line)
+                    row.push(specifier);
+                else
+                    rows.push([specifier]);
+            }
+            /**
+             * The names rewritten to fill lines from `column`, breaking to `indent` where they must.
+             *
+             * `tail` is what follows the last name on its line — a comma, the closing brace, the
+             * module — which is part of that line's length even though it is not a name.
+             */
+            const rewrapped = (names, column, indent, tail) => {
+                let text = '';
+                let width = column;
+                for (const [i, specifier] of names.entries()) {
+                    const name = source.getText(specifier);
+                    const last = i === names.length - 1;
+                    // A comma follows every name but the last, which carries the tail instead.
+                    const owed = last ? tail : 1;
+                    if (i === 0) {
+                        text = name;
+                        width += name.length;
+                    }
+                    else if (width + 2 + name.length + owed <= maxLen) {
+                        text += `, ${name}`;
+                        width += 2 + name.length;
+                    }
+                    else {
+                        text += `,${eol}${indent}${name}`;
+                        width = indent.length + name.length;
+                    }
+                }
+                return text;
+            };
+            const indentOf = (line) => line === node.loc.start.line ? `${base}    ` : /^[^\S\r\n]*/.exec(lineAt(line - 1))?.[0] ?? `${base}    `;
+            const spanOf = (names) => [names[0].range[0], names[names.length - 1].range[1]];
+            // To the end of the statement, not the end of the line: a comment beside an import is not
+            // the import's length, and breaking the names would not shorten it.
+            const widthAt = (line) => line === node.loc.end.line ? node.loc.end.column : lineAt(line - 1).trimEnd().length;
+            /** What sits after these names on their last line, and so shares it. */
+            const tailOf = (names) => {
+                const last = names[names.length - 1];
+                return Math.max(widthAt(last.loc.end.line) - last.loc.end.column, 0);
+            };
+            const report = (names, on, messageId) => {
+                const span = spanOf(names);
+                const text = rewrapped(names, names[0].loc.start.column, indentOf(names[0].loc.start.line), tailOf(names));
+                if (text === source.text.slice(...span))
                     return false;
+                context.report({
+                    node: on,
+                    messageId,
+                    data: { maxLen: String(maxLen) },
+                    fix: fixer => fixer.replaceTextRange(span, text),
+                });
+                return true;
+            };
+            // A line over the limit with one name on it is over because of what surrounds the name, so
+            // the braces are what has to give: the names take lines of their own.
+            const overLong = rows.find(row => row[0] && widthAt(row[0].loc.start.line) > maxLen);
+            if (overLong && !BREAK.test(written)) {
+                const indent = `${base}    `;
+                const prefix = flattened(source.text.slice(node.range[0], open.range[1]));
+                const suffix = flattened(source.text.slice(close.range[0], node.range[1]));
+                const names = rewrapped(specifiers, indent.length, indent, 0);
+                context.report({
+                    node,
+                    messageId: 'nameLineTooLong',
+                    data: { maxLen: String(maxLen) },
+                    fix: fixer => fixer.replaceTextRange(node.range, `${prefix}${eol}${indent}${names}${eol}${base}${suffix}`),
+                });
+                return true;
             }
-            const current = `${base}${source.getText(node)}`;
-            if (wanted === current)
-                return false;
-            context.report({
-                node,
-                messageId: 'manageLineLength',
-                data: { maxLen: String(maxLen) },
-                fix: fixer => fixer.replaceTextRange(node.range, wanted.slice(base.length)),
-            });
-            return true;
+            // Names of one kind to a line, so a value never joins a line of types, or the other way.
+            // A row holding both is the order check's to sort out, and stands alone here.
+            const kindOf = (row) => {
+                const types = row.filter(isTypeSpecifier).length;
+                return types === 0 ? 'value' : types === row.length ? 'type' : 'mixed';
+            };
+            const runs = [];
+            for (const row of rows) {
+                const run = runs[runs.length - 1];
+                const previous = run?.[run.length - 1];
+                if (run && previous && kindOf(previous) === kindOf(row) && kindOf(row) !== 'mixed')
+                    run.push(row);
+                else
+                    runs.push([row]);
+            }
+            // A run at a time, since one line's names spilling down changes what the next line can hold;
+            // fixing a pair at a time would need a pass for every line.
+            for (const run of runs) {
+                const names = run.flat();
+                const long = run.some(row => widthAt(row[0].loc.start.line) > maxLen);
+                const on = long
+                    ? names.find(specifier => specifier.loc.end.column > maxLen) ?? names[1] ?? names[0]
+                    : (run[1]?.[0] ?? names[0]);
+                if (report(names, on, long ? 'nameLineTooLong' : 'nameFitsAbove'))
+                    return true;
+            }
+            return false;
         };
         /** Whether it reported the layout, which leaves the order and shape checks nothing to say. */
         const checkBraces = (node, specifiers) => {
@@ -470,7 +563,7 @@ const rule = {
             const close = source.getTokenAfter(last, { filter: token => token.value === '}' });
             if (!open || !close)
                 return false;
-            if (manageLineLength && checkPacking(node, specifiers, open, close))
+            if (manageLineLength && checkLineLength(node, specifiers, open, close))
                 return true;
             // To the module, not the statement's end, so a multiline `with { … }` is not counted.
             const end = node.source ?? close;

package/package.json

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