@kununu/eslint-config 5.2.3-beta-1 → 5.2.3-beta-3

package/index.js

@@ -1,6 +1,3 @@
-// Register our custom plugin
-require('eslint/lib/cli-engine/config/plugins').define('custom', require('./eslint-plugin-custom'));
-
 // we need to have the baseRules to have the same on the typescript override
 // because it has extends the eslint does not take into consideration the ones from the base
 const baseRules = {
@@ -207,71 +204,7 @@ const baseRules = {
   // https://react.dev/blog/2024/04/25/react-19-upgrade-guide#removed-proptypes-and-defaultprops
   'react/require-default-props': 0,
 
-  'custom/prefer-early-return': {
-    meta: {
-      type: 'suggestion',
-      docs: {
-        description: 'Prefer early returns over logical expressions in return statements',
-        category: 'Best Practices',
-        recommended: true,
-      },
-      fixable: 'code',
-    },
-    create(context) {
-      return {
-        ReturnStatement(node) {
-          const argument = node.argument?.type === 'ParenthesizedExpression' 
-            ? node.argument.expression 
-            : node.argument;
-
-          // Check if it's a sequence expression (comma-separated expressions)
-          if (argument?.type === 'SequenceExpression') {
-            const expressions = argument.expressions;
-            
-            // Check if we have logical expressions with && in the sequence
-            const logicalExpressions = expressions.filter(expr => 
-              expr.type === 'LogicalExpression' && expr.operator === '&&'
-            );
-            
-            if (logicalExpressions.length > 0) {
-              context.report({
-                node,
-                message: 'Prefer early returns over comma-separated logical expressions',
-                fix(fixer) {
-                  const sourceCode = context.getSourceCode();
-                  
-                  // Create a replacement string for the entire return
-                  let replacement = '';
-                  
-                  expressions.forEach((expr, index) => {
-                    const isLast = index === expressions.length - 1;
-                    
-                    if (expr.type === 'LogicalExpression' && expr.operator === '&&') {
-                      const condition = sourceCode.getText(expr.left);
-                      const value = sourceCode.getText(expr.right);
-                      
-                      if (isLast && expressions.length > 1) {
-                        // Last expression gets a simple return
-                        replacement += `return ${value};`;
-                      } else {
-                        // Others get a conditional return
-                        replacement += `if (${condition}) return ${value};\n`;
-                      }
-                    } else if (isLast) {
-                      // Last non-logical expression gets a simple return
-                      replacement += `return ${sourceCode.getText(expr)};`;
-                    }
-                  });
-                  
-                  return fixer.replaceText(node, replacement);
-                }
-              });
-            }
-          }
-        }
-      };
-    }
-  },
+  "prefer-early-return": require("./rules/prefer-early-return"),
 };
 
 module.exports = {
@@ -291,7 +224,6 @@ module.exports = {
     '@babel',
     'lodash',
     'sort-destructure-keys',
-    'custom'
   ],
 
   env: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kununu/eslint-config",
-  "version": "5.2.3-beta-1",
+  "version": "5.2.3-beta-3",
   "description": "kununu's ESLint config",
   "main": "index.js",
   "repository": "kununu/eslint-config",

package/rules/prefer-early-return.js

@@ -0,0 +1,71 @@
+"use strict";
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Prefer early returns over logical expressions in return statements",
+            category: "Best Practices",
+            recommended: true,
+        },
+        fixable: "code",
+    },
+    create: (context) => {
+        return {
+            ReturnStatement: (node) => {
+                const argument =
+                    node.argument?.type === "ParenthesizedExpression"
+                        ? node.argument.expression
+                        : node.argument;
+
+                if (argument?.type === "SequenceExpression") {
+                    const expressions = argument.expressions;
+
+                    const logicalExpressions = expressions.filter(
+                        (expr) =>
+                            expr.type === "LogicalExpression" &&
+                            expr.operator === "&&"
+                    );
+
+                    if (logicalExpressions.length > 0) {
+                        context.report({
+                            node,
+                            message:
+                                "Prefer early returns over comma-separated logical expressions",
+                            fix: (fixer) => {
+                                const sourceCode = context.getSourceCode();
+                                let replacement = "";
+
+                                expressions.forEach((expr, index) => {
+                                    const isLast = index === expressions.length - 1;
+
+                                    if (
+                                        expr.type === "LogicalExpression" &&
+                                        expr.operator === "&&"
+                                    ) {
+                                        const condition = sourceCode.getText(
+                                            expr.left
+                                        );
+                                        const value = sourceCode.getText(expr.right);
+
+                                        if (isLast && expressions.length > 1) {
+                                            replacement += `return ${value};`;
+                                        } else {
+                                            replacement += `if (${condition}) return ${value};\n`;
+                                        }
+                                    } else if (isLast) {
+                                        replacement += `return ${sourceCode.getText(
+                                            expr
+                                        )};`;
+                                    }
+                                });
+
+                                return fixer.replaceText(node, replacement);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};