new copy

Author: Shinigami92

eslint.config.ts

@@ -270,25 +270,25 @@ export default defineConfig(
   //#endregion
 
   {
-    name: 'custom',
+    name: "custom",
     plugins: {
       custom: {
         rules: {
-          'no-arrow-parameter-types': {
+          "no-arrow-parameter-types": {
             meta: {
-              fixable: 'code',
+              fixable: "code",
               hasSuggestions: true,
-              type: 'suggestion',
-              dialects: ['typescript'],
+              type: "suggestion",
+              dialects: ["typescript"],
               schema: [
                 {
-                  type: 'object',
+                  type: "object",
                   properties: {
                     allowOptional: {
-                      type: 'boolean',
+                      type: "boolean",
                       default: false,
                       description:
-                        'Allow type annotations when the parameter is optional. Sometimes useful for overloaded functions.',
+                        "Allow type annotations when the parameter is optional. Sometimes useful for overloaded functions.",
                     },
                   },
                 },
@@ -307,12 +307,12 @@ export default defineConfig(
                   const paramsWithTypeAnnotation = node.params.filter(
                     (
                       // @ts-expect-error: will be inferred when moved into an official plugin
-                      param
-                    ) => param.typeAnnotation !== undefined
+                      param,
+                    ) => param.typeAnnotation !== undefined,
                   );
 
                   const isCatchClause =
-                    node.parent.callee?.property?.name === 'catch';
+                    node.parent.callee?.property?.name === "catch";
 
                   if (paramsWithTypeAnnotation.length > 0 && !isCatchClause) {
                     for (const param of paramsWithTypeAnnotation) {
@@ -323,51 +323,116 @@ export default defineConfig(
                       context.report({
                         node: param,
                         message:
-                          'Arrow function parameters should not have type annotations. Instead the Object where the operation is used should be typed correctly.',
+                          "Arrow function parameters should not have type annotations. Instead the Object where the operation is used should be typed correctly.",
                         fix(fixer) {
                           if (param.optional) {
                             return null;
                           }
 
-                          // TODO @Shinigami92 2025-06-16: Handle async arrow functions
-                          if (node.parent.type === 'VariableDeclarator') {
-                            const variableDeclaratorNode = node.parent;
+                          if (
+                            node.parent.type === "VariableDeclarator" &&
+                            !node.parent.id.typeAnnotation
+                          ) {
+                            const variableDeclarationNode = node.parent;
 
-                            return [
-                              // Remove ` =>`
+                            const isAsyncFunction: boolean = node.async;
+
+                            const isBodyBlockStatement =
+                              node.body.type === "BlockStatement";
+
+                            const isBodyJSXElement =
+                              node.body.type === "JSXElement";
+
+                            const hasReturnType = node.returnType !== undefined;
+
+                            const lastParam = node.params.at(-1);
+
+                            const paramIdDifferentLine =
+                              lastParam.loc.start.line !==
+                              variableDeclarationNode.id.loc.end.line;
+
+                            const paramBlockDifferentLine =
+                              lastParam.loc.end.line !==
+                              node.body.loc.start.line;
+
+                            const behindClosingParenthesis = hasReturnType
+                              ? (node.returnType.range[1] as number)
+                              : (lastParam.range[1] as number) + ")".length;
+
+                            const fixes = [
+                              // Removes `=> `
                               fixer.replaceTextRange(
-                                [node.body.range[0] - 3, node.body.range[0]],
-                                ''
+                                [
+                                  behindClosingParenthesis,
+                                  node.body.range[0] as number,
+                                ],
+                                !hasReturnType &&
+                                  paramBlockDifferentLine &&
+                                  paramIdDifferentLine
+                                  ? ")"
+                                  : "",
                               ),
-                              // Remove ` = `
+                              // Removes ` = ` or ` = async `
                               fixer.replaceTextRange(
                                 [
-                                  variableDeclaratorNode.id.range[1],
-                                  variableDeclaratorNode.init.range[0],
+                                  variableDeclarationNode.id.range[1] as number,
+                                  (variableDeclarationNode.init
+                                    .range[0] as number) +
+                                    (isAsyncFunction ? "async ".length : 0),
                                 ],
-                                ''
+                                "",
                               ),
-                              // Replace `const ` with `function `
+                              // Replaces `const ` with `function ` or `async function `
                               fixer.replaceTextRange(
                                 [
-                                  variableDeclaratorNode.parent.range[0],
-                                  variableDeclaratorNode.range[0],
+                                  variableDeclarationNode.parent
+                                    .range[0] as number,
+                                  variableDeclarationNode.range[0] as number,
                                 ],
-                                'function '
+                                isAsyncFunction
+                                  ? "async function "
+                                  : "function ",
                               ),
                             ];
+
+                            // If the body is not a BlockStatement, we need to wrap it in curly braces
+                            if (!isBodyBlockStatement) {
+                              fixes.push(
+                                fixer.insertTextBefore(
+                                  node.body,
+                                  `{return ${isBodyJSXElement ? "(" : ""}`,
+                                ),
+                                fixer.insertTextAfter(
+                                  node.body,
+                                  `${isBodyJSXElement ? ")" : ""}}`,
+                                ),
+                              );
+
+                              if (isBodyJSXElement) {
+                                fixes.push(
+                                  fixer.removeRange([
+                                    node.body.range[1] as number,
+                                    node.range[1] as number,
+                                  ]),
+                                );
+                              }
+                            }
+
+                            return fixes;
                           }
 
-                          return fixer.removeRange(param.typeAnnotation.range);
+                          return fixer.removeRange(
+                            param.typeAnnotation.range as [number, number],
+                          );
                         },
                         suggest: [
                           {
-                            desc: 'Remove type annotation',
+                            desc: "Remove type annotation",
                             fix(fixer) {
                               if (param.optional) {
                                 return fixer.removeRange([
-                                  param.typeAnnotation.range[0] - 1, // Remove the `?` before the type annotation
-                                  param.typeAnnotation.range[1],
+                                  (param.typeAnnotation.range[0] as number) - 1, // Remove the `?` before the type annotation
+                                  param.typeAnnotation.range[1] as number,
                                 ]);
                               }
 
@@ -386,7 +451,7 @@ export default defineConfig(
       },
     },
     rules: {
-      'custom/no-arrow-parameter-types': ['error', { allowOptional: true }],
+      "custom/no-arrow-parameter-types": ["error", { allowOptional: true }],
     },
-  }
+  },
 );