@lsby/eslint-plugin 0.0.18 → 0.0.19

package/dist/index.js

@@ -4,18 +4,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const no_definite_assignment_assertion_1 = __importDefault(require("./lib/rules/no-definite-assignment-assertion"));
+const no_early_return_on_equality_1 = __importDefault(require("./lib/rules/no-early-return-on-equality"));
 const no_else_on_equality_1 = __importDefault(require("./lib/rules/no-else-on-equality"));
 const no_negation_1 = __importDefault(require("./lib/rules/no-negation"));
 const no_switch_default_1 = __importDefault(require("./lib/rules/no-switch-default"));
 const prefer_let_1 = __importDefault(require("./lib/rules/prefer-let"));
-const prefer_switch_over_multi_if_1 = __importDefault(require("./lib/rules/prefer-switch-over-multi-if"));
 module.exports = {
     rules: {
         'prefer-let': prefer_let_1.default,
         'no-negation': no_negation_1.default,
         'no-definite-assignment-assertion': no_definite_assignment_assertion_1.default,
+        'no-early-return-on-equality': no_early_return_on_equality_1.default,
         'no-else-on-equality': no_else_on_equality_1.default,
         'no-switch-default': no_switch_default_1.default,
-        'prefer-switch-over-multi-if': prefer_switch_over_multi_if_1.default,
     },
 };

package/dist/lib/rules/{prefer-switch-over-multi-if.d.ts → no-early-return-on-equality.d.ts}

@@ -1,3 +1,3 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-declare const rule: TSESLint.RuleModule<'preferSwitch', []>;
+declare const rule: TSESLint.RuleModule<'noEarlyReturnOnEquality', []>;
 export default rule;

package/dist/lib/rules/no-early-return-on-equality.js

@@ -0,0 +1,57 @@
+"use strict";
+// 禁止等于条件的if提前返回，但允许不等于条件的提前返回
+// 使用等于条件的提前返回容易遗漏状态，应该用正向的不等于条件或结构化流程
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: '禁止在等于条件下使用提前返回(early return)。使用不等于条件的提前返回会更清晰地表达程序的主要流程',
+        },
+        messages: {
+            noEarlyReturnOnEquality: '禁止在等于条件下使用提前返回。建议改用不等于条件的提前返回，使主流程更清晰。例如：将 if (x === y) return; 改为 if (x !== y) { 主要逻辑 }',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * 检查条件中是否是等于操作符（不包括不等于）
+         */
+        function isEqualityOperator(node) {
+            if (node.type === 'BinaryExpression') {
+                return ['===', '=='].includes(node.operator);
+            }
+            if (node.type === 'LogicalExpression') {
+                return isEqualityOperator(node.left) || isEqualityOperator(node.right);
+            }
+            return false;
+        }
+        /**
+         * 检查语句是否是提前返回或抛出（仅包含这些语句）
+         */
+        function isEarlyExit(node) {
+            if (!node)
+                return false;
+            // 直接是 return 或 throw
+            if (node.type === 'ReturnStatement' || node.type === 'ThrowStatement') {
+                return true;
+            }
+            // 是 block statement，检查其中的所有语句是否都是 return 或 throw
+            if (node.type === 'BlockStatement') {
+                return (node.body.length > 0 &&
+                    node.body.every((stmt) => stmt.type === 'ReturnStatement' || stmt.type === 'ThrowStatement'));
+            }
+            return false;
+        }
+        return {
+            IfStatement(node) {
+                // 检查：条件是等于 & if 分支是提前返回 & 没有 else 分支
+                if (!node.alternate && isEqualityOperator(node.test) && isEarlyExit(node.consequent)) {
+                    context.report({ node, messageId: 'noEarlyReturnOnEquality' });
+                }
+            },
+        };
+    },
+};
+exports.default = rule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsby/eslint-plugin",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [

package/dist/lib/rules/prefer-switch-over-multi-if.js

@@ -1,108 +0,0 @@
-"use strict";
-// 建议使用 switch 替代多个 if 判断同一变量
-// 当有多个连续的 if 语句判断同一个表达式时, 应该使用 switch 来提高代码的可读性
-Object.defineProperty(exports, "__esModule", { value: true });
-const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: { description: '检测多个连续 if 判断同一个表达式，建议使用 switch 提高可读性' },
-        messages: { preferSwitch: '检测到 {{count}} 个连续的 if 判断同一个表达式，可以考虑使用 switch 提高可读性' },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const minIfs = 2;
-        function getText(node) {
-            return sourceCode.getText(node);
-        }
-        function isValidCaseValue(node) {
-            return (node.type === 'Literal' ||
-                node.type === 'TemplateLiteral' ||
-                node.type === 'Identifier' ||
-                node.type === 'MemberExpression');
-        }
-        function getSwitchInfo(test) {
-            if (test.type !== 'BinaryExpression')
-                return null;
-            // 支持所有的二元比较操作符
-            const comparisonOps = ['===', '==', '!==', '!=', '>', '<', '>=', '<='];
-            if (!comparisonOps.includes(test.operator))
-                return null;
-            const left = test.left;
-            const right = test.right;
-            if ((left.type === 'Identifier' || left.type === 'MemberExpression') && isValidCaseValue(right)) {
-                return { variable: getText(left), value: getText(right) };
-            }
-            if ((right.type === 'Identifier' || right.type === 'MemberExpression') && isValidCaseValue(left)) {
-                return { variable: getText(right), value: getText(left) };
-            }
-            return null;
-        }
-        function collectIfChain(node) {
-            const chain = [node];
-            let current = node;
-            // 收集 else-if 链
-            while (current.alternate && current.alternate.type === 'IfStatement') {
-                chain.push(current.alternate);
-                current = current.alternate;
-            }
-            // 如果没有 else-if，尝试收集相邻的 if 语句
-            if (chain.length === 1 && node.parent) {
-                const parent = node.parent;
-                let body = null;
-                if (parent.type === 'BlockStatement') {
-                    body = parent.body;
-                }
-                else if (parent.type === 'Program') {
-                    body = parent.body;
-                }
-                if (body) {
-                    const nodeIndex = body.indexOf(node);
-                    if (nodeIndex !== -1) {
-                        const firstInfo = getSwitchInfo(node.test);
-                        if (firstInfo) {
-                            let nextIndex = nodeIndex + 1;
-                            while (nextIndex < body.length && body[nextIndex].type === 'IfStatement') {
-                                const nextIfStmt = body[nextIndex];
-                                if (nextIfStmt.alternate)
-                                    break; // 如果有 else/else-if，停止
-                                const nextInfo = getSwitchInfo(nextIfStmt.test);
-                                if (!nextInfo || nextInfo.variable !== firstInfo.variable)
-                                    break; // 变量不同，停止
-                                chain.push(nextIfStmt);
-                                nextIndex++;
-                            }
-                        }
-                    }
-                }
-            }
-            return chain;
-        }
-        function allSameVariable(chain) {
-            if (chain.length < minIfs)
-                return null;
-            const firstInfo = getSwitchInfo(chain[0].test);
-            if (!firstInfo)
-                return null;
-            for (const stmt of chain.slice(1)) {
-                const info = getSwitchInfo(stmt.test);
-                if (!info || info.variable !== firstInfo.variable)
-                    return null;
-            }
-            return { variable: firstInfo.variable, count: chain.length };
-        }
-        return {
-            IfStatement(node) {
-                if (node.parent?.type === 'IfStatement' && node.parent.alternate === node)
-                    return;
-                const chain = collectIfChain(node);
-                const info = allSameVariable(chain);
-                if (!info)
-                    return;
-                context.report({ node, messageId: 'preferSwitch', data: { count: info.count } });
-            },
-        };
-    },
-};
-exports.default = rule;