@kikiutils/eslint-config 9.3.2 → 10.1.0

package/src/_internals/rules/consistent-parameter-layout.ts

@@ -1,4 +1,7 @@
-import type { Rule } from 'eslint';
+import type {
+    AST,
+    Rule,
+} from 'eslint';
 
 import type { TokenStore } from '../utils';
 import { defineScriptAndTemplateVisitors } from '../utils';
@@ -13,120 +16,188 @@ type ListItem = CallNode['arguments'][number] | FunctionNode['params'][number];
 
 export const consistentParameterLayout: Rule.RuleModule = {
     create(context) {
-        const isTestFile = /\.test\.[jt]sx?$/.test(context.filename);
-
-        function checkParameterLayout(
-            node: Rule.Node,
-            items: readonly ListItem[],
-            tokenStore: TokenStore,
-            isTemplate: boolean,
-        ): void {
-            const first = items[0];
-            if (!first) return;
-            const isSingleParameter = items.length === 1;
-
-            // JSX argument layout belongs to the JSX formatting rules.
-            const firstType: string = first.type;
-            if (isSingleParameter && (firstType === 'JSXElement' || firstType === 'JSXFragment')) return;
-            let openingParen;
-            if (node.type === 'CallExpression' || node.type === 'NewExpression') {
-                const call = node as CallNode;
-                openingParen = tokenStore.getTokenAfter(
-                    call.typeArguments ?? call.callee,
-                    (token) => token.type === 'Punctuator' && token.value === '(',
-                );
-            } else {
-                openingParen = tokenStore.getTokenBefore(first);
-            }
+        const compactTestCalls = context.options[0]?.compactTestCalls === true;
 
-            if (!openingParen || openingParen.value !== '(') return;
-            // An unparenthesized arrow must not borrow its parent's delimiters.
-            if (openingParen.range[0] < node.range![0]) return;
-            const closingParen = node.type === 'CallExpression' || node.type === 'NewExpression'
-                ? tokenStore.getLastToken(node)
-                : tokenStore.getTokenAfter(items.at(-1)!, (token) => token.value === ')');
-
-            const next = tokenStore.getTokenAfter(openingParen)!;
+        function createVisitor(tokenStore: TokenStore, isTemplate: boolean): Rule.RuleListener {
+            function checkTestCallLayout(node: CallNode): void {
+                const items = node.arguments;
+                if (!items.length) return;
+                const openingParen = tokenStore.getTokenAfter(
+                    node.typeArguments ?? node.callee,
+                    (token) => token.type === 'Punctuator' && token.value === '(',
+                )!;
+
+                const closingParen = tokenStore.getLastToken(node)!;
+                const previous = tokenStore.getTokenBefore(closingParen)!;
+                const gaps: Array<[AST.Token, AST.Token, string]> = [
+                    [
+                        openingParen,
+                        tokenStore.getTokenAfter(openingParen)!,
+                        '',
+                    ],
+                    [
+                        previous,
+                        closingParen,
+                        '',
+                    ],
+                ];
 
-            if (isSingleParameter) {
-                if (!closingParen || closingParen.value !== ')') return;
-                let previous = tokenStore.getTokenBefore(closingParen)!;
-                if (previous.value === ',') previous = tokenStore.getTokenBefore(previous)!;
-                if (
-                    tokenStore.commentsExistBetween(openingParen, next)
-                    || tokenStore.commentsExistBetween(previous, closingParen)
-                ) return;
+                for (let index = 1; index < items.length; index++) {
+                    const comma = tokenStore.getTokensBetween(items[index - 1]!, items[index]!)
+                        .find((token) => token.type === 'Punctuator' && token.value === ',')!;
+
+                    gaps.push(
+                        [
+                            tokenStore.getTokenBefore(comma)!,
+                            comma,
+                            '',
+                        ],
+                        [
+                            comma,
+                            tokenStore.getTokenAfter(comma)!,
+                            ' ',
+                        ],
+                    );
+                }
 
-                const hasOpeningNewline = openingParen.loc.end.line !== next.loc.start.line;
-                const hasClosingNewline = tokenStore.getTokenBefore(closingParen)!.loc.end.line
-                  !== closingParen.loc.start.line;
+                if (previous.value === ',') {
+                    gaps.push([
+                        tokenStore.getTokenBefore(previous)!,
+                        previous,
+                        '',
+                    ]);
+                }
 
-                if (hasOpeningNewline === hasClosingNewline) return;
+                // Keep the whole list's layout when a boundary comment prevents safe compaction.
+                if (gaps.some(([left, right]) => tokenStore.commentsExistBetween(left, right))) return;
+                const multilineGaps = gaps.filter(([left, right]) => left.loc.end.line !== right.loc.start.line);
+                if (!multilineGaps.length) return;
 
                 context.report({
-                    fix: (fixer) => hasOpeningNewline
-                        ? fixer.insertTextBefore(closingParen, '\n')
-                        : fixer.insertTextAfter(openingParen, '\n'),
-                    messageId: 'singleBoundary',
+                    fix: (fixer) => multilineGaps.map(([
+                        left,
+                        right,
+                        text,
+                    ]) => fixer.replaceTextRange(
+                        [
+                            left.range[1],
+                            right.range[0],
+                        ],
+                        text,
+                    )),
+                    messageId: 'compactTestCall',
                     node,
                 });
-
-                return;
             }
 
-            if (!closingParen || openingParen.loc.start.line === closingParen.loc.end.line) return;
+            function checkParameterLayout(
+                node: CallNode | FunctionNode,
+                items: readonly ListItem[],
+            ): void {
+                const first = items[0];
+                if (!first) return;
+                const isSingleParameter = items.length === 1;
+
+                // JSX argument layout belongs to the JSX formatting rules.
+                const firstType: string = first.type;
+                if (isSingleParameter && (firstType === 'JSXElement' || firstType === 'JSXFragment')) return;
+                let openingParen;
+                if (node.type === 'CallExpression' || node.type === 'NewExpression') {
+                    openingParen = tokenStore.getTokenAfter(
+                        node.typeArguments ?? node.callee,
+                        (token) => token.type === 'Punctuator' && token.value === '(',
+                    );
+                } else {
+                    openingParen = tokenStore.getTokenBefore(first);
+                }
 
-            if (isTemplate) {
-                // Script list formatters do not traverse Vue template expressions.
-                const newlineOffsets: number[] = [];
-                if (openingParen.loc.end.line === next.loc.start.line) newlineOffsets.push(openingParen.range[1]);
-                for (let index = 1; index < items.length; index++) {
-                    const item = items[index]!;
-                    const comma = tokenStore.getTokensBetween(items[index - 1]!, item)
-                        .find((token) => token.value === ',');
+                if (!openingParen || openingParen.value !== '(') return;
+                // An unparenthesized arrow must not borrow its parent's delimiters.
+                if (openingParen.range[0] < node.range![0]) return;
+                const closingParen = node.type === 'CallExpression' || node.type === 'NewExpression'
+                    ? tokenStore.getLastToken(node)
+                    : tokenStore.getTokenAfter(items.at(-1)!, (token) => token.value === ')');
 
-                    if (comma && comma.loc.end.line === tokenStore.getTokenAfter(comma)!.loc.start.line) {
-                        newlineOffsets.push(comma.range[1]);
-                    }
-                }
+                const next = tokenStore.getTokenAfter(openingParen)!;
+
+                if (isSingleParameter) {
+                    if (!closingParen || closingParen.value !== ')') return;
+                    let previous = tokenStore.getTokenBefore(closingParen)!;
+                    if (previous.value === ',') previous = tokenStore.getTokenBefore(previous)!;
+                    if (
+                        tokenStore.commentsExistBetween(openingParen, next)
+                        || tokenStore.commentsExistBetween(previous, closingParen)
+                    ) return;
+
+                    const hasOpeningNewline = openingParen.loc.end.line !== next.loc.start.line;
+                    const hasClosingNewline = tokenStore.getTokenBefore(closingParen)!.loc.end.line
+                      !== closingParen.loc.start.line;
 
-                if (
-                    closingParen.value === ')'
-                    && tokenStore.getTokenBefore(closingParen)!.loc.end.line === closingParen.loc.start.line
-                ) newlineOffsets.push(closingParen.range[0]);
+                    if (hasOpeningNewline === hasClosingNewline) return;
 
-                if (newlineOffsets.length) {
                     context.report({
-                        fix: (fixer) => newlineOffsets.map((offset) => fixer.insertTextAfterRange(
-                            [
-                                offset,
-                                offset,
-                            ],
-                            '\n',
-                        )),
-                        messageId: 'newline',
-                        node: first,
+                        fix: (fixer) => hasOpeningNewline
+                            ? fixer.insertTextBefore(closingParen, '\n')
+                            : fixer.insertTextAfter(openingParen, '\n'),
+                        messageId: 'singleBoundary',
+                        node,
                     });
+
+                    return;
                 }
 
-                return;
-            }
+                if (!closingParen || openingParen.loc.start.line === closingParen.loc.end.line) return;
 
-            if (openingParen.loc.end.line !== next.loc.start.line) return;
+                if (isTemplate) {
+                    // Script list formatters do not traverse Vue template expressions.
+                    const newlineOffsets: number[] = [];
+                    if (openingParen.loc.end.line === next.loc.start.line) newlineOffsets.push(openingParen.range[1]);
+                    for (let index = 1; index < items.length; index++) {
+                        const item = items[index]!;
+                        const comma = tokenStore.getTokensBetween(items[index - 1]!, item)
+                            .find((token) => token.value === ',');
 
-            context.report({
-                fix: (fixer) => fixer.insertTextAfter(openingParen, '\n'),
-                messageId: 'newline',
-                node: first,
-            });
-        }
+                        if (comma && comma.loc.end.line === tokenStore.getTokenAfter(comma)!.loc.start.line) {
+                            newlineOffsets.push(comma.range[1]);
+                        }
+                    }
+
+                    if (
+                        closingParen.value === ')'
+                        && tokenStore.getTokenBefore(closingParen)!.loc.end.line === closingParen.loc.start.line
+                    ) newlineOffsets.push(closingParen.range[0]);
+
+                    if (newlineOffsets.length) {
+                        context.report({
+                            fix: (fixer) => newlineOffsets.map((offset) => fixer.insertTextBeforeRange(
+                                [
+                                    offset,
+                                    offset,
+                                ],
+                                '\n',
+                            )),
+                            messageId: 'newline',
+                            node: first,
+                        });
+                    }
+
+                    return;
+                }
+
+                if (openingParen.loc.end.line !== next.loc.start.line) return;
+
+                context.report({
+                    fix: (fixer) => fixer.insertTextAfter(openingParen, '\n'),
+                    messageId: 'newline',
+                    node: first,
+                });
+            }
 
-        function createVisitor(tokenStore: TokenStore, isTemplate: boolean): Rule.RuleListener {
             return {
-                ArrowFunctionExpression: (node) => checkParameterLayout(node, node.params, tokenStore, isTemplate),
+                ArrowFunctionExpression: (node) => checkParameterLayout(node, node.params),
                 CallExpression: (node) => {
                     const { callee } = node;
-                    if (isTestFile) {
+                    if (compactTestCalls) {
                         const target = callee.type === 'MemberExpression'
                           && !callee.computed
                           && callee.property.type === 'Identifier'
@@ -137,27 +208,37 @@ export const consistentParameterLayout: Rule.RuleModule = {
                         if (
                             target.type === 'Identifier'
                             && (target.name === 'describe' || target.name === 'it')
-                        ) return;
+                        ) {
+                            checkTestCallLayout(node);
+                            return;
+                        }
                     }
 
-                    checkParameterLayout(node, node.arguments, tokenStore, isTemplate);
+                    checkParameterLayout(node, node.arguments);
                 },
-                FunctionDeclaration: (node) => checkParameterLayout(node, node.params, tokenStore, isTemplate),
-                FunctionExpression: (node) => checkParameterLayout(node, node.params, tokenStore, isTemplate),
-                NewExpression: (node) => checkParameterLayout(node, node.arguments, tokenStore, isTemplate),
+                FunctionDeclaration: (node) => checkParameterLayout(node, node.params),
+                FunctionExpression: (node) => checkParameterLayout(node, node.params),
+                NewExpression: (node) => checkParameterLayout(node, node.arguments),
             };
         }
 
         return defineScriptAndTemplateVisitors(context.sourceCode, createVisitor);
     },
     meta: {
-        docs: { description: 'Preserve consistent single-parameter boundaries and expand multiline parameter lists.' },
+        docs: { description: 'Keep parameter boundaries consistent, expand multiline lists, and compact test calls.' },
         fixable: 'whitespace',
         messages: {
+            compactTestCall: 'Keep test-call arguments beside their parentheses and each other.',
             newline: 'Start a multiline parameter list on a new line.',
             singleBoundary: 'Use matching newline boundaries around a single parameter.',
         },
-        schema: [],
+        schema: [
+            {
+                additionalProperties: false,
+                properties: { compactTestCalls: { type: 'boolean' } },
+                type: 'object',
+            },
+        ],
         type: 'layout',
     },
 };

package/src/_internals/rules/statement-padding.ts

@@ -10,12 +10,20 @@ export const statementPadding: Rule.RuleModule = {
             for (let index = 1; index < statements.length; index++) {
                 const previous = statements[index - 1]!;
                 const next = statements[index]!;
+                if (
+                    [
+                        previous,
+                        next,
+                    ].some((node) =>
+                        node.type === 'ImportDeclaration'
+                        || node.type === 'ExportAllDeclaration'
+                        || (node.type === 'ExportNamedDeclaration' && node.source))
+                ) continue;
+
+                const previousFirstToken = sourceCode.getFirstToken(previous)!;
                 const lastToken = sourceCode.getLastToken(previous)!;
                 const firstToken = sourceCode.getFirstToken(next)!;
-                const closingLine = sourceCode.lines[lastToken.loc.end.line - 1]!;
-                const openingLine = sourceCode.lines[firstToken.loc.start.line - 1]!;
-                const hasDifferentIndent = /^\s*/.exec(closingLine)![0] !== /^\s*/.exec(openingLine)![0];
-                const hasStandaloneClosing = /^[)\]}]+;?$/.test(closingLine.slice(0, lastToken.loc.end.column).trim());
+                const isMultiline = previousFirstToken.loc.start.line !== lastToken.loc.end.line;
                 const blockNode = previous.type === 'ExportDefaultDeclaration'
                   || previous.type === 'ExportNamedDeclaration'
                     ? previous.declaration
@@ -36,24 +44,27 @@ export const statementPadding: Rule.RuleModule = {
                     'WithStatement',
                 ].includes(blockNode.type);
 
-                if (!hasDifferentIndent && !hasStandaloneClosing && !hasBlockClosing) continue;
-                const comments = sourceCode.getCommentsBefore(next);
-                if (
-                    sourceCode
-                        .lines
-                        .slice(lastToken.loc.end.line, firstToken.loc.start.line - 1)
-                        .some((line, index) => !line.trim() && !comments.some((comment) =>
-                            comment.loc!.start.line <= lastToken.loc.end.line + index + 1
-                            && comment.loc!.end.line >= lastToken.loc.end.line + index + 1))
-                ) continue;
+                if (!isMultiline && !hasBlockClosing) continue;
+                let previousEnd = lastToken.range[1];
+                let previousEndLine = lastToken.loc.end.line;
+                let nextStart = firstToken.range[0];
+                let nextStartLine = firstToken.loc.start.line;
 
-                // Keep leading comments attached to the next statement and trailing comments in place.
-                const boundary = comments
-                    .find((comment) => comment.loc!.start.line > lastToken.loc.end.line) ?? firstToken;
+                // Include trailing comments in the previous boundary, not leading comments of the next statement.
+                for (const comment of sourceCode.getCommentsBefore(next)) {
+                    if (comment.loc!.start.line === previousEndLine) {
+                        previousEnd = comment.range![1];
+                        previousEndLine = comment.loc!.end.line;
+                    } else {
+                        nextStart = comment.range![0];
+                        nextStartLine = comment.loc!.start.line;
+                        break;
+                    }
+                }
 
-                const offset = boundary.loc!.start.line > lastToken.loc.end.line
-                    ? boundary.range![0] - boundary.loc!.start.column
-                    : boundary.range![0];
+                if (nextStartLine > previousEndLine + 1) continue;
+                const linebreakIndex = sourceCode.text.slice(previousEnd, nextStart).indexOf('\n');
+                const offset = linebreakIndex === -1 ? nextStart : previousEnd + linebreakIndex + 1;
 
                 context.report({
                     fix: (fixer) => fixer.insertTextBeforeRange(
@@ -61,7 +72,7 @@ export const statementPadding: Rule.RuleModule = {
                             offset,
                             offset,
                         ],
-                        boundary.loc!.start.line === lastToken.loc.end.line ? '\n\n' : '\n',
+                        linebreakIndex === -1 ? '\n\n' : '\n',
                     ),
                     messageId: 'blankLine',
                     node: next,
@@ -77,7 +88,7 @@ export const statementPadding: Rule.RuleModule = {
         };
     },
     meta: {
-        docs: { description: 'Separate statements after closing lines, blocks, or indentation changes.' },
+        docs: { description: 'Separate complete multiline statements and block-ending statements with blank lines.' },
         fixable: 'whitespace',
         messages: { blankLine: 'Add a blank line between these complete statements.' },
         schema: [],

package/src/_internals/type-aware.ts

@@ -0,0 +1,28 @@
+import type { TypedFlatConfigItem } from '@antfu/eslint-config';
+
+export function createTypeAwareConfig(): TypedFlatConfigItem {
+    return {
+        languageOptions: {
+            parserOptions: {
+                projectService: true,
+                tsconfigRootDir: process.cwd(),
+            },
+        },
+        rules: {
+            'require-await': 'off',
+            'ts/await-thenable': 'error',
+            'ts/no-base-to-string': 'error',
+            'ts/no-floating-promises': 'error',
+            'ts/no-for-in-array': 'error',
+            'ts/no-misused-promises': 'error',
+            'ts/no-misused-spread': 'error',
+            'ts/no-unnecessary-type-assertion': 'error',
+            'ts/require-await': 'error',
+            'ts/return-await': 'error',
+            'ts/switch-exhaustiveness-check': [
+                'error',
+                { considerDefaultExhaustiveForUnions: true },
+            ],
+        },
+    };
+}