@kikiutils/eslint-config 9.2.0 → 9.3.0

package/dist/vue.js

@@ -1,3 +1,4 @@
+import { customPlugins } from "./internals/plugins.js";
 import { createBaseRules } from "./base.js";
 import promise from "eslint-plugin-promise";
 import kikiutilsEslintPluginVue from "@kikiutils/eslint-plugin-vue";
@@ -9,6 +10,7 @@ function createVueConfig(environment = "node") {
 		plugins: {
 			"@kikiutils/vue": kikiutilsEslintPluginVue,
 			"better-tailwindcss": betteTailwindcss,
+			"kikiutils": customPlugins,
 			promise
 		},
 		rules: {

package/dist/vue.js.map

@@ -1 +1 @@
-{"version":3,"file":"vue.js","names":[],"sources":["../src/vue.ts"],"sourcesContent":["import type { TypedFlatConfigItem } from '@antfu/eslint-config';\nimport kikiutilsEslintPluginVue from '@kikiutils/eslint-plugin-vue';\nimport betteTailwindcss from 'eslint-plugin-better-tailwindcss';\n// @ts-expect-error No declare file.\nimport promise from 'eslint-plugin-promise';\n\nimport { createBaseRules } from './base';\n\nexport function createVueConfig(environment: 'bun' | 'node' = 'node'): TypedFlatConfigItem {\n    return {\n        files: ['**/*.vue'],\n        plugins: {\n            '@kikiutils/vue': kikiutilsEslintPluginVue,\n            'better-tailwindcss': betteTailwindcss,\n            promise,\n        },\n        rules: {\n            ...createBaseRules(environment),\n            '@kikiutils/vue/attributes-order': [\n                'error',\n                {\n                    alphabetical: true,\n                    alphabeticalEnhanced: true,\n                },\n            ],\n            '@kikiutils/vue/class-hex-color-case': 'error',\n            'better-tailwindcss/enforce-consistent-class-order': 'error',\n            'better-tailwindcss/enforce-consistent-important-position': 'error',\n            'better-tailwindcss/enforce-consistent-variable-syntax': 'error',\n            'better-tailwindcss/enforce-consistent-variant-order': 'error',\n            'better-tailwindcss/enforce-shorthand-classes': 'error',\n            'better-tailwindcss/no-deprecated-classes': 'warn',\n            'better-tailwindcss/no-duplicate-classes': 'error',\n            'better-tailwindcss/no-unnecessary-whitespace': 'error',\n            'style/max-len': 'off',\n            'vue/attribute-hyphenation': 'error',\n            'vue/attributes-order': 'off',\n            'vue/block-order': [\n                'error',\n                {\n                    order: [\n                        'template',\n                        'script',\n                        'style',\n                    ],\n                },\n            ],\n            'vue/component-api-style': 'error',\n            'vue/define-emits-declaration': 'error',\n            'vue/define-props-declaration': 'error',\n            'vue/enforce-style-attribute': 'error',\n            'vue/html-closing-bracket-newline': 'error',\n            'vue/html-closing-bracket-spacing': 'error',\n            'vue/html-indent': [\n                'error',\n                4,\n            ],\n            'vue/max-attributes-per-line': [\n                'error',\n                {\n                    multiline: 1,\n                    singleline: 1,\n                },\n            ],\n            'vue/max-len': [\n                'warn',\n                {\n                    code: 120,\n                    comments: 120,\n                    template: 120,\n                },\n            ],\n            'vue/no-dupe-keys': 'error',\n            'vue/no-lone-template': 'error',\n            'vue/no-multi-spaces': 'error',\n            'vue/no-multiple-objects-in-class': 'error',\n            'vue/no-root-v-if': 'error',\n            'vue/no-template-target-blank': 'error',\n            'vue/no-v-html': 'error',\n            'vue/prefer-define-options': 'error',\n            'vue/prefer-separate-static-class': 'error',\n            'vue/require-explicit-emits': 'error',\n            'vue/require-typed-ref': 'error',\n        },\n    };\n}\n"],"mappings":";;;;;AAQA,SAAgB,gBAAgB,cAA8B,QAA6B;CACvF,OAAO;EACH,OAAO,CAAC,UAAU;EAClB,SAAS;GACL,kBAAkB;GAClB,sBAAsB;GACtB;EACJ;EACA,OAAO;GACH,GAAG,gBAAgB,WAAW;GAC9B,mCAAmC,CAC/B,SACA;IACI,cAAc;IACd,sBAAsB;GAC1B,CACJ;GACA,uCAAuC;GACvC,qDAAqD;GACrD,4DAA4D;GAC5D,yDAAyD;GACzD,uDAAuD;GACvD,gDAAgD;GAChD,4CAA4C;GAC5C,2CAA2C;GAC3C,gDAAgD;GAChD,iBAAiB;GACjB,6BAA6B;GAC7B,wBAAwB;GACxB,mBAAmB,CACf,SACA,EACI,OAAO;IACH;IACA;IACA;GACJ,EACJ,CACJ;GACA,2BAA2B;GAC3B,gCAAgC;GAChC,gCAAgC;GAChC,+BAA+B;GAC/B,oCAAoC;GACpC,oCAAoC;GACpC,mBAAmB,CACf,SACA,CACJ;GACA,+BAA+B,CAC3B,SACA;IACI,WAAW;IACX,YAAY;GAChB,CACJ;GACA,eAAe,CACX,QACA;IACI,MAAM;IACN,UAAU;IACV,UAAU;GACd,CACJ;GACA,oBAAoB;GACpB,wBAAwB;GACxB,uBAAuB;GACvB,oCAAoC;GACpC,oBAAoB;GACpB,gCAAgC;GAChC,iBAAiB;GACjB,6BAA6B;GAC7B,oCAAoC;GACpC,8BAA8B;GAC9B,yBAAyB;EAC7B;CACJ;AACJ"}
+{"version":3,"file":"vue.js","names":[],"sources":["../src/vue.ts"],"sourcesContent":["import type { TypedFlatConfigItem } from '@antfu/eslint-config';\nimport kikiutilsEslintPluginVue from '@kikiutils/eslint-plugin-vue';\nimport betteTailwindcss from 'eslint-plugin-better-tailwindcss';\n// @ts-expect-error No declare file.\nimport promise from 'eslint-plugin-promise';\n\nimport { createBaseRules } from './base';\nimport { customPlugins } from './internals/plugins';\n\nexport function createVueConfig(environment: 'bun' | 'node' = 'node'): TypedFlatConfigItem {\n    return {\n        files: ['**/*.vue'],\n        plugins: {\n            '@kikiutils/vue': kikiutilsEslintPluginVue,\n            'better-tailwindcss': betteTailwindcss,\n            'kikiutils': customPlugins,\n            promise,\n        },\n        rules: {\n            ...createBaseRules(environment),\n            '@kikiutils/vue/attributes-order': [\n                'error',\n                {\n                    alphabetical: true,\n                    alphabeticalEnhanced: true,\n                },\n            ],\n            '@kikiutils/vue/class-hex-color-case': 'error',\n            'better-tailwindcss/enforce-consistent-class-order': 'error',\n            'better-tailwindcss/enforce-consistent-important-position': 'error',\n            'better-tailwindcss/enforce-consistent-variable-syntax': 'error',\n            'better-tailwindcss/enforce-consistent-variant-order': 'error',\n            'better-tailwindcss/enforce-shorthand-classes': 'error',\n            'better-tailwindcss/no-deprecated-classes': 'warn',\n            'better-tailwindcss/no-duplicate-classes': 'error',\n            'better-tailwindcss/no-unnecessary-whitespace': 'error',\n            'style/max-len': 'off',\n            'vue/attribute-hyphenation': 'error',\n            'vue/attributes-order': 'off',\n            'vue/block-order': [\n                'error',\n                {\n                    order: [\n                        'template',\n                        'script',\n                        'style',\n                    ],\n                },\n            ],\n            'vue/component-api-style': 'error',\n            'vue/define-emits-declaration': 'error',\n            'vue/define-props-declaration': 'error',\n            'vue/enforce-style-attribute': 'error',\n            'vue/html-closing-bracket-newline': 'error',\n            'vue/html-closing-bracket-spacing': 'error',\n            'vue/html-indent': [\n                'error',\n                4,\n            ],\n            'vue/max-attributes-per-line': [\n                'error',\n                {\n                    multiline: 1,\n                    singleline: 1,\n                },\n            ],\n            'vue/max-len': [\n                'warn',\n                {\n                    code: 120,\n                    comments: 120,\n                    template: 120,\n                },\n            ],\n            'vue/no-dupe-keys': 'error',\n            'vue/no-lone-template': 'error',\n            'vue/no-multi-spaces': 'error',\n            'vue/no-multiple-objects-in-class': 'error',\n            'vue/no-root-v-if': 'error',\n            'vue/no-template-target-blank': 'error',\n            'vue/no-v-html': 'error',\n            'vue/prefer-define-options': 'error',\n            'vue/prefer-separate-static-class': 'error',\n            'vue/require-explicit-emits': 'error',\n            'vue/require-typed-ref': 'error',\n        },\n    };\n}\n"],"mappings":";;;;;;AASA,SAAgB,gBAAgB,cAA8B,QAA6B;CACvF,OAAO;EACH,OAAO,CAAC,UAAU;EAClB,SAAS;GACL,kBAAkB;GAClB,sBAAsB;GACtB,aAAa;GACb;EACJ;EACA,OAAO;GACH,GAAG,gBAAgB,WAAW;GAC9B,mCAAmC,CAC/B,SACA;IACI,cAAc;IACd,sBAAsB;GAC1B,CACJ;GACA,uCAAuC;GACvC,qDAAqD;GACrD,4DAA4D;GAC5D,yDAAyD;GACzD,uDAAuD;GACvD,gDAAgD;GAChD,4CAA4C;GAC5C,2CAA2C;GAC3C,gDAAgD;GAChD,iBAAiB;GACjB,6BAA6B;GAC7B,wBAAwB;GACxB,mBAAmB,CACf,SACA,EACI,OAAO;IACH;IACA;IACA;GACJ,EACJ,CACJ;GACA,2BAA2B;GAC3B,gCAAgC;GAChC,gCAAgC;GAChC,+BAA+B;GAC/B,oCAAoC;GACpC,oCAAoC;GACpC,mBAAmB,CACf,SACA,CACJ;GACA,+BAA+B,CAC3B,SACA;IACI,WAAW;IACX,YAAY;GAChB,CACJ;GACA,eAAe,CACX,QACA;IACI,MAAM;IACN,UAAU;IACV,UAAU;GACd,CACJ;GACA,oBAAoB;GACpB,wBAAwB;GACxB,uBAAuB;GACvB,oCAAoC;GACpC,oBAAoB;GACpB,gCAAgC;GAChC,iBAAiB;GACjB,6BAA6B;GAC7B,oCAAoC;GACpC,8BAA8B;GAC9B,yBAAyB;EAC7B;CACJ;AACJ"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kikiutils/eslint-config",
   "type": "module",
-  "version": "9.2.0",
+  "version": "9.3.0",
   "description": "Using antfu/eslint-config as a base for eslint-config, slightly modified the settings and added additional plugins, mainly for my own use.",
   "author": "kiki-kanri",
   "license": "MIT",
@@ -12,6 +12,36 @@
   "keywords": [],
   "sideEffects": false,
   "exports": {
+    "./internals/plugins": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./internals/rules/compact-iteration-layout": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./internals/rules/consistent-condition-layout": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./internals/rules/consistent-parameter-layout": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./internals/rules/statement-padding": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./internals/utils": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
     "./package.json": "./package.json",
     "./*": "./dist/*.js"
   },
@@ -36,16 +66,16 @@
     "typecheck": "tsc -b --noEmit"
   },
   "peerDependencies": {
-    "@antfu/eslint-config": "^9.0.0",
-    "@eslint/css": "^1.1.0",
-    "@html-eslint/parser": ">=0.61.0",
+    "@antfu/eslint-config": "^9.5.1",
+    "@eslint/css": "^2.0.0",
+    "@html-eslint/parser": ">=0.65.0",
     "@kikiutils/eslint-plugin-vue": "^10.10.0",
     "eslint": ">=9.0.0",
-    "eslint-plugin-better-tailwindcss": "^4.4.0",
-    "eslint-plugin-format": ">=1.0.0",
-    "tailwind-csstree": "^0.3.1",
-    "tailwindcss": ">=4.0.0",
-    "vue-eslint-parser": "^10.4.0"
+    "eslint-plugin-better-tailwindcss": "^4.7.0",
+    "eslint-plugin-format": ">=2.0.1",
+    "tailwind-csstree": "^0.4.0",
+    "tailwindcss": ">=4.3.3",
+    "vue-eslint-parser": "^10.4.1"
   },
   "peerDependenciesMeta": {
     "@eslint/css": {
@@ -80,20 +110,20 @@
     "eslint-plugin-promise": "^7.3.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^9.1.0",
-    "@kikiutils/eslint-plugin-vue": "^10.10.0",
-    "@kikiutils/tsconfigs": "^6.0.0",
-    "@types/node": "^26.1.0",
-    "@vitest/coverage-v8": "^4.1.9",
+    "@antfu/eslint-config": "^9.5.1",
+    "@kikiutils/eslint-config": "^9.2.1",
+    "@kikiutils/tsconfigs": "^7.0.0",
+    "@types/node": "^26.6.4",
+    "@vitest/coverage-v8": "^5.0.3",
     "changelogen": "^0.6.2",
-    "eslint": "^10.6.0",
-    "eslint-plugin-better-tailwindcss": "^4.6.0",
+    "eslint": "^10.12.0",
+    "eslint-plugin-better-tailwindcss": "^4.7.0",
     "eslint-plugin-format": "^2.0.1",
-    "knip": "^6.24.0",
-    "publint": "^0.3.21",
-    "tsdown": "^0.22.3",
+    "knip": "^6.39.0",
+    "publint": "^0.3.25",
+    "tsdown": "^0.23.0",
     "typescript": "^6.0.3",
-    "unplugin-unused": "^0.5.7",
-    "vitest": "^4.1.9"
+    "unplugin-unused": "^0.6.0",
+    "vitest": "^5.0.3"
   }
 }

package/src/base.ts

@@ -5,11 +5,15 @@ import type {
 // @ts-expect-error No declare file.
 import promise from 'eslint-plugin-promise';
 
+import { customPlugins } from './internals/plugins';
+
+// Constants/Variables
 const basePerfectionistSortOptions = {
     ignoreCase: false,
     type: 'natural',
 } as const;
 
+// Functions
 export function createBaseConfigs(environment: 'bun' | 'node' = 'node'): TypedFlatConfigItem[] {
     return [
         // All files
@@ -30,7 +34,10 @@ export function createBaseConfigs(environment: 'bun' | 'node' = 'node'): TypedFl
         // JavaScript
         {
             files: ['**/*.{cjs,js,mjs}'],
-            plugins: { promise },
+            plugins: {
+                kikiutils: customPlugins,
+                promise,
+            },
             rules: {
                 ...createBaseRules(environment),
                 'node/prefer-global/process': [
@@ -42,7 +49,10 @@ export function createBaseConfigs(environment: 'bun' | 'node' = 'node'): TypedFl
         // TypeScript
         {
             files: ['**/*.{ts,tsx}'],
-            plugins: { promise },
+            plugins: {
+                kikiutils: customPlugins,
+                promise,
+            },
             rules: {
                 ...createBaseRules(environment),
                 'node/prefer-global/process': [
@@ -95,10 +105,18 @@ export function createBaseRules(environment: 'bun' | 'node' = 'node'): Rules {
         'antfu/curly': 'off',
         'antfu/if-newline': 'off',
         'antfu/no-top-level-await': 'off',
+        'arrow-body-style': [
+            'error',
+            'as-needed',
+        ],
         'curly': [
             'error',
             'multi-line',
         ],
+        'kikiutils/compact-iteration-layout': 'error',
+        'kikiutils/consistent-condition-layout': 'error',
+        'kikiutils/consistent-parameter-layout': 'error',
+        'kikiutils/statement-padding': 'error',
         'max-classes-per-file': [
             'error',
             1,

package/src/internals/plugins.ts

@@ -0,0 +1,13 @@
+import { compactIterationLayout } from './rules/compact-iteration-layout';
+import { consistentConditionLayout } from './rules/consistent-condition-layout';
+import { consistentParameterLayout } from './rules/consistent-parameter-layout';
+import { statementPadding } from './rules/statement-padding';
+
+export const customPlugins = {
+    rules: {
+        'compact-iteration-layout': compactIterationLayout,
+        'consistent-condition-layout': consistentConditionLayout,
+        'consistent-parameter-layout': consistentParameterLayout,
+        'statement-padding': statementPadding,
+    },
+};

package/src/internals/rules/compact-iteration-layout.ts

@@ -0,0 +1,57 @@
+import type { Rule } from 'eslint';
+
+type IterationNode = Extract<Rule.Node, { type: 'ForInStatement' | 'ForOfStatement' }>;
+
+export const compactIterationLayout: Rule.RuleModule = {
+    create(context) {
+        const { sourceCode } = context;
+
+        function checkParentheses(node: IterationNode): void {
+            const openingParen = sourceCode.getFirstToken(node, (token) => token.value === '(')!;
+            const closingParen = sourceCode.getTokenBefore(node.body)!;
+            const next = sourceCode.getTokenAfter(openingParen)!;
+            const previous = sourceCode.getTokenBefore(closingParen)!;
+            const ranges: Array<[number, number]> = [];
+
+            if (
+                openingParen.loc.end.line !== next.loc.start.line
+                && !sourceCode.commentsExistBetween(openingParen, next)
+            ) {
+                ranges.push([
+                    openingParen.range[1],
+                    next.range[0],
+                ]);
+            }
+
+            if (
+                previous.loc.end.line !== closingParen.loc.start.line
+                && !sourceCode.commentsExistBetween(previous, closingParen)
+            ) {
+                ranges.push([
+                    previous.range[1],
+                    closingParen.range[0],
+                ]);
+            }
+
+            if (ranges.length) {
+                context.report({
+                    fix: (fixer) => ranges.map((range) => fixer.replaceTextRange(range, '')),
+                    messageId: 'compact',
+                    node,
+                });
+            }
+        }
+
+        return {
+            ForInStatement: checkParentheses,
+            ForOfStatement: checkParentheses,
+        };
+    },
+    meta: {
+        docs: { description: 'Keep for-in and for-of parentheses beside their header contents.' },
+        fixable: 'whitespace',
+        messages: { compact: 'Keep iteration parentheses on the same lines as their adjacent header contents.' },
+        schema: [],
+        type: 'layout',
+    },
+};

package/src/internals/rules/consistent-condition-layout.ts

@@ -0,0 +1,130 @@
+import type {
+    AST,
+    Rule,
+} from 'eslint';
+
+import type { TokenStore } from '../utils';
+import { defineScriptAndTemplateVisitors } from '../utils';
+
+type LogicalNode = Extract<Rule.Node, { type: 'LogicalExpression' }>;
+
+export const consistentConditionLayout: Rule.RuleModule = {
+    create(context) {
+        function createVisitor(tokenStore: TokenStore): Rule.RuleListener {
+            const checkedOpeningOffsets = new Set<number>();
+
+            function collectOperators(node: LogicalNode['left'], operators: AST.Token[]): void {
+                if (node.type !== 'LogicalExpression' || (node.operator !== '&&' && node.operator !== '||')) return;
+                const operator = tokenStore.getTokensBetween(node.left, node.right)
+                    .find((token) => token.type === 'Punctuator' && token.value === node.operator)!;
+
+                function collectChild(child: LogicalNode['left']): void {
+                    const before = tokenStore.getTokenBefore(child);
+                    const after = tokenStore.getTokenAfter(child);
+                    if (
+                        before?.value === '('
+                        && after?.value === ')'
+                        && before.range[0] >= node.range![0]
+                        && after.range[1] <= node.range![1]
+                    ) return;
+
+                    collectOperators(child, operators);
+                }
+
+                collectChild(node.left);
+                operators.push(operator);
+                collectChild(node.right);
+            }
+
+            function checkParentheses(node: LogicalNode['left']): void {
+                let openingParen = tokenStore.getTokenBefore(node);
+                let closingParen = tokenStore.getTokenAfter(node);
+                let operators: AST.Token[] | undefined;
+                const newlineOffsets: number[] = [];
+                while (openingParen?.value === '(' && closingParen?.value === ')') {
+                    if (
+                        !checkedOpeningOffsets.has(openingParen.range[0])
+                        && openingParen.loc.start.line !== closingParen.loc.end.line
+                    ) {
+                        checkedOpeningOffsets.add(openingParen.range[0]);
+                        if (!operators) {
+                            operators = [];
+                            collectOperators(node, operators);
+                        }
+
+                        const next = tokenStore.getTokenAfter(openingParen)!;
+                        if (openingParen.loc.end.line === next.loc.start.line) {
+                            newlineOffsets.push(openingParen.range[1]);
+                        }
+
+                        for (const operator of operators) {
+                            if (tokenStore.getTokenBefore(operator)!.loc.end.line === operator.loc.start.line) {
+                                newlineOffsets.push(operator.range[0]);
+                            }
+                        }
+
+                        if (tokenStore.getTokenBefore(closingParen)!.loc.end.line === closingParen.loc.start.line) {
+                            newlineOffsets.push(closingParen.range[0]);
+                        }
+                    }
+
+                    openingParen = tokenStore.getTokenBefore(openingParen);
+                    closingParen = tokenStore.getTokenAfter(closingParen);
+                    // An outer pair contains one grouped item, not the inner logical chain.
+                    operators = [];
+                }
+
+                if (newlineOffsets.length) {
+                    context.report({
+                        fix: (fixer) => newlineOffsets.map((offset) => fixer.insertTextBeforeRange(
+                            [
+                                offset,
+                                offset,
+                            ],
+                            '\n',
+                        )),
+                        messageId: 'newline',
+                        node,
+                    });
+                }
+            }
+
+            return {
+                BinaryExpression: (node) => {
+                    if (
+                        [
+                            '!=',
+                            '!==',
+                            '<',
+                            '<=',
+                            '==',
+                            '===',
+                            '>',
+                            '>=',
+                            'in',
+                            'instanceof',
+                        ].includes(node.operator)
+                    ) checkParentheses(node);
+                },
+                DoWhileStatement: (node) => checkParentheses(node.test),
+                IfStatement: (node) => checkParentheses(node.test),
+                LogicalExpression: (node) => {
+                    if (node.operator === '&&' || node.operator === '||') checkParentheses(node);
+                },
+                UnaryExpression: (node) => {
+                    if (node.operator === '!') checkParentheses(node);
+                },
+                WhileStatement: (node) => checkParentheses(node.test),
+            };
+        }
+
+        return defineScriptAndTemplateVisitors(context.sourceCode, createVisitor);
+    },
+    meta: {
+        docs: { description: 'Expand multiline parenthesized conditions one logical item per line.' },
+        fixable: 'whitespace',
+        messages: { newline: 'Put each logical item and both parentheses on separate lines in a multiline condition.' },
+        schema: [],
+        type: 'layout',
+    },
+};

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

@@ -0,0 +1,163 @@
+import type { Rule } from 'eslint';
+
+import type { TokenStore } from '../utils';
+import { defineScriptAndTemplateVisitors } from '../utils';
+
+type CallNode = Extract<Rule.Node, { type: 'CallExpression' | 'NewExpression' }> & { typeArguments?: Rule.Node };
+type FunctionNode = Extract<
+    Rule.Node,
+    { type: 'ArrowFunctionExpression' | 'FunctionDeclaration' | 'FunctionExpression' }
+>;
+
+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);
+            }
+
+            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)!;
+
+            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 (hasOpeningNewline === hasClosingNewline) return;
+
+                context.report({
+                    fix: (fixer) => hasOpeningNewline
+                        ? fixer.insertTextBefore(closingParen, '\n')
+                        : fixer.insertTextAfter(openingParen, '\n'),
+                    messageId: 'singleBoundary',
+                    node,
+                });
+
+                return;
+            }
+
+            if (!closingParen || openingParen.loc.start.line === closingParen.loc.end.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 === ',');
+
+                    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.insertTextAfterRange(
+                            [
+                                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),
+                CallExpression: (node) => {
+                    const { callee } = node;
+                    if (isTestFile) {
+                        const target = callee.type === 'MemberExpression'
+                          && !callee.computed
+                          && callee.property.type === 'Identifier'
+                          && callee.property.name === 'concurrent'
+                            ? callee.object
+                            : callee;
+
+                        if (
+                            target.type === 'Identifier'
+                            && (target.name === 'describe' || target.name === 'it')
+                        ) return;
+                    }
+
+                    checkParameterLayout(node, node.arguments, tokenStore, isTemplate);
+                },
+                FunctionDeclaration: (node) => checkParameterLayout(node, node.params, tokenStore, isTemplate),
+                FunctionExpression: (node) => checkParameterLayout(node, node.params, tokenStore, isTemplate),
+                NewExpression: (node) => checkParameterLayout(node, node.arguments, tokenStore, isTemplate),
+            };
+        }
+
+        return defineScriptAndTemplateVisitors(context.sourceCode, createVisitor);
+    },
+    meta: {
+        docs: { description: 'Preserve consistent single-parameter boundaries and expand multiline parameter lists.' },
+        fixable: 'whitespace',
+        messages: {
+            newline: 'Start a multiline parameter list on a new line.',
+            singleBoundary: 'Use matching newline boundaries around a single parameter.',
+        },
+        schema: [],
+        type: 'layout',
+    },
+};

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

@@ -0,0 +1,86 @@
+import type { Rule } from 'eslint';
+
+type StatementNode = Extract<Rule.Node, { type: 'Program' }>['body'][number];
+
+export const statementPadding: Rule.RuleModule = {
+    create(context) {
+        const { sourceCode } = context;
+
+        function checkStatements(statements: readonly StatementNode[]): void {
+            for (let index = 1; index < statements.length; index++) {
+                const previous = statements[index - 1]!;
+                const next = statements[index]!;
+                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 blockNode = previous.type === 'ExportDefaultDeclaration'
+                  || previous.type === 'ExportNamedDeclaration'
+                    ? previous.declaration
+                    : previous;
+
+                const hasBlockClosing = lastToken.value === '}' && blockNode && [
+                    'BlockStatement',
+                    'ClassDeclaration',
+                    'ForInStatement',
+                    'ForOfStatement',
+                    'ForStatement',
+                    'FunctionDeclaration',
+                    'IfStatement',
+                    'LabeledStatement',
+                    'SwitchStatement',
+                    'TryStatement',
+                    'WhileStatement',
+                    '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;
+
+                // 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;
+
+                const offset = boundary.loc!.start.line > lastToken.loc.end.line
+                    ? boundary.range![0] - boundary.loc!.start.column
+                    : boundary.range![0];
+
+                context.report({
+                    fix: (fixer) => fixer.insertTextBeforeRange(
+                        [
+                            offset,
+                            offset,
+                        ],
+                        boundary.loc!.start.line === lastToken.loc.end.line ? '\n\n' : '\n',
+                    ),
+                    messageId: 'blankLine',
+                    node: next,
+                });
+            }
+        }
+
+        return {
+            BlockStatement: (node) => checkStatements(node.body),
+            Program: (node) => checkStatements(node.body),
+            StaticBlock: (node) => checkStatements(node.body),
+            SwitchCase: (node) => checkStatements(node.consequent),
+        };
+    },
+    meta: {
+        docs: { description: 'Separate statements after closing lines, blocks, or indentation changes.' },
+        fixable: 'whitespace',
+        messages: { blankLine: 'Add a blank line between these complete statements.' },
+        schema: [],
+        type: 'layout',
+    },
+};