eslint-plugin-code-style 1.14.1 → 1.14.3

package/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.14.3] - 2026-02-05
+
+### Enhanced
+
+- **`type-annotation-spacing`** - Add auto-fix to collapse function types with 2 or fewer params to one line
+- **`interface-format`** - Fix circular fix conflict by skipping collapse when property has multi-line function type
+
+---
+
+## [1.14.2] - 2026-02-05
+
+### Enhanced
+
+- **`type-annotation-spacing`** - Add spacing rules for async keyword and function types:
+  - Enforce space after `async` keyword: `async()` → `async ()`
+  - Enforce space after `=>` in function types: `() =>void` → `() => void`
+  - Format function types with 3+ params on multiple lines
+- **`interface-format`** - Skip collapsing single-property interfaces when property has function type with 3+ params
+
+---
+
 ## [1.14.1] - 2026-02-05
 
 ### Enhanced
@@ -1666,6 +1687,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.14.3]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.14.2...v1.14.3
+[1.14.2]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.14.1...v1.14.2
 [1.14.1]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.14.0...v1.14.1
 [1.14.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.13.0...v1.14.0
 [1.13.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.12.1...v1.13.0

package/index.js

@@ -19980,6 +19980,57 @@ const typeAnnotationSpacing = {
         const sourceCode = context.sourceCode || context.getSourceCode();
 
         return {
+            ArrowFunctionExpression(node) {
+                // Check for space after async keyword: async() => -> async () =>
+                if (node.async) {
+                    const asyncToken = sourceCode.getFirstToken(node, (t) => t.value === "async");
+                    const openParen = sourceCode.getTokenAfter(asyncToken, (t) => t.value === "(");
+
+                    if (asyncToken && openParen) {
+                        const textBetween = sourceCode.text.slice(asyncToken.range[1], openParen.range[0]);
+
+                        // Should have exactly one space after async
+                        if (textBetween === "") {
+                            context.report({
+                                fix: (fixer) => fixer.insertTextAfter(asyncToken, " "),
+                                message: "Missing space after async keyword",
+                                node: asyncToken,
+                            });
+                        } else if (textBetween !== " " && !textBetween.includes("\n")) {
+                            // Has extra spaces but not newline
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange([asyncToken.range[1], openParen.range[0]], " "),
+                                message: "Should have exactly one space after async keyword",
+                                node: asyncToken,
+                            });
+                        }
+                    }
+                }
+            },
+            FunctionExpression(node) {
+                // Check for space after async keyword in function expressions: async function() -> async function ()
+                if (node.async) {
+                    const asyncToken = sourceCode.getFirstToken(node, (t) => t.value === "async");
+                    const functionToken = sourceCode.getTokenAfter(asyncToken, (t) => t.value === "function");
+
+                    if (functionToken) {
+                        const openParen = sourceCode.getTokenAfter(functionToken, (t) => t.value === "(");
+
+                        if (openParen) {
+                            const textBetween = sourceCode.text.slice(functionToken.range[1], openParen.range[0]);
+
+                            // Should have exactly one space after function keyword
+                            if (textBetween === "") {
+                                context.report({
+                                    fix: (fixer) => fixer.insertTextAfter(functionToken, " "),
+                                    message: "Missing space after function keyword",
+                                    node: functionToken,
+                                });
+                            }
+                        }
+                    }
+                }
+            },
             TSArrayType(node) {
                 // Check for space before [] like: Type []
                 const elementType = node.elementType;
@@ -20365,6 +20416,83 @@ const typeAnnotationSpacing = {
                     }
                 }
             },
+            TSFunctionType(node) {
+                // Check for space after => in function types: () =>void -> () => void
+                // Find the arrow token by searching all tokens in the node
+                const tokens = sourceCode.getTokens(node);
+                const arrowToken = tokens.find((t) => t.value === "=>");
+
+                if (arrowToken) {
+                    const nextToken = sourceCode.getTokenAfter(arrowToken);
+
+                    if (nextToken) {
+                        const textAfterArrow = sourceCode.text.slice(arrowToken.range[1], nextToken.range[0]);
+
+                        // Should have exactly one space after =>
+                        if (textAfterArrow === "") {
+                            context.report({
+                                fix: (fixer) => fixer.insertTextAfter(arrowToken, " "),
+                                message: "Missing space after => in function type",
+                                node: arrowToken,
+                            });
+                        } else if (textAfterArrow !== " " && !textAfterArrow.includes("\n")) {
+                            // Has extra spaces but not newline
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange([arrowToken.range[1], nextToken.range[0]], " "),
+                                message: "Should have exactly one space after => in function type",
+                                node: arrowToken,
+                            });
+                        }
+                    }
+                }
+
+                // Check function type params formatting
+                // - 3+ params should be multiline
+                // - 0-2 params should be on one line
+                const params = node.params;
+                const openParen = tokens.find((t) => t.value === "(");
+
+                if (openParen && arrowToken) {
+                    const closeParen = sourceCode.getTokenBefore(arrowToken, (t) => t.value === ")");
+
+                    if (closeParen) {
+                        const isMultiLine = openParen.loc.start.line !== closeParen.loc.end.line;
+
+                        if (params && params.length >= 3 && !isMultiLine) {
+                            // 3+ params on one line - expand to multiple lines
+                            const lineStart = sourceCode.text.lastIndexOf("\n", node.range[0]) + 1;
+                            const lineText = sourceCode.text.slice(lineStart, node.range[0]);
+                            const match = lineText.match(/^(\s*)/);
+                            const baseIndent = match ? match[1] : "";
+                            const paramIndent = baseIndent + "    ";
+
+                            const formattedParams = params.map((p) => {
+                                const paramText = sourceCode.getText(p);
+
+                                return paramIndent + paramText;
+                            }).join(",\n");
+
+                            const newParamsText = `(\n${formattedParams},\n${baseIndent})`;
+
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange([openParen.range[0], closeParen.range[1]], newParamsText),
+                                message: "Function type with 3+ parameters should have each parameter on its own line",
+                                node,
+                            });
+                        } else if (params && params.length <= 2 && isMultiLine) {
+                            // 0-2 params on multiple lines - collapse to one line
+                            const formattedParams = params.map((p) => sourceCode.getText(p).trim()).join(", ");
+                            const newParamsText = `(${formattedParams})`;
+
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange([openParen.range[0], closeParen.range[1]], newParamsText),
+                                message: "Function type with 2 or fewer parameters should be on one line",
+                                node,
+                            });
+                        }
+                    }
+                }
+            },
             VariableDeclarator(node) {
                 // Check for space before generic like: ColumnDef <T>
                 if (node.id && node.id.typeAnnotation) {
@@ -21833,6 +21961,7 @@ const interfaceFormat = {
 
                 // For single member, should be on one line without trailing punctuation
                 // But skip if the property has a nested object type with 2+ members
+                // Or if the property has a multi-line function type (let type-annotation-spacing handle it first)
                 if (members.length === 1) {
                     const member = members[0];
                     const isMultiLine = openBraceToken.loc.end.line !== closeBraceToken.loc.start.line;
@@ -21843,7 +21972,11 @@ const interfaceFormat = {
                     const hasMultiMemberNestedType = hasNestedType && nestedType.members?.length >= 2;
                     const hasSingleMemberNestedType = hasNestedType && nestedType.members?.length === 1;
 
-                    if (isMultiLine && !hasMultiMemberNestedType) {
+                    // Check if property has function type that spans multiple lines
+                    const hasMultiLineFunctionType = nestedType?.type === "TSFunctionType" &&
+                        nestedType.loc.start.line !== nestedType.loc.end.line;
+
+                    if (isMultiLine && !hasMultiMemberNestedType && !hasMultiLineFunctionType) {
                         // Build the collapsed text, handling nested types specially
                         let cleanText;
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-code-style",
-    "version": "1.14.1",
+    "version": "1.14.3",
     "description": "A custom ESLint plugin for enforcing consistent code formatting and style rules in React/JSX projects",
     "main": "index.js",
     "types": "index.d.ts",