@lsby/eslint-plugin 0.0.17 → 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_else_1 = __importDefault(require("./lib/rules/no-else"));
+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-else': no_else_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/dist/lib/rules/no-else-on-equality.js

@@ -0,0 +1,40 @@
+"use strict";
+// 禁止 else（当条件是等于或不等于时）
+// 对于等于/不等于的条件判断，else 表示"除当前条件外的所有可能"
+// 当状态集合未来扩展时, 依然会被包含在else分支里, 导致状态遗漏却无任何报错
+// 应当使用提早返回 或 switch + 穷尽检查
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: { description: '当条件是等于或不等于时，禁止使用 else 分支，防止隐含的状态遗漏' },
+        messages: {
+            noElse: '禁止在等于/不等于条件下使用 else 分支。当条件状态扩展时, else 分支可能遗漏新的状态。请改用提前返回(early return)或 switch 语句',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * 检查条件中是否包含等于或不等于操作符
+         */
+        function hasEqualityOperator(node) {
+            if (node.type === 'BinaryExpression') {
+                return ['===', '!==', '==', '!='].includes(node.operator);
+            }
+            if (node.type === 'LogicalExpression') {
+                return hasEqualityOperator(node.left) || hasEqualityOperator(node.right);
+            }
+            return false;
+        }
+        return {
+            IfStatement(node) {
+                // 仅在 if 条件是等于或不等于的情况下，禁止 else
+                if (node.alternate !== null && hasEqualityOperator(node.test)) {
+                    context.report({ node: node.alternate, messageId: 'noElse' });
+                }
+            },
+        };
+    },
+};
+exports.default = rule;

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@lsby/eslint-plugin",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "rimraf dist && tsc",
     "check:all": "npm run check:format && npm run check:type",
     "check:format": "prettier --write .",
     "check:type": "tsc --noEmit",
     "dev": "tsc --watch",
     "pub:public": "npm run build && npm run test && bumpp && npm publish --access public",
-    "test": "mocha test/**/*.test.js"
+    "test": "npm run build && mocha test/**/*.test.js"
   },
   "devDependencies": {
     "@ianvs/prettier-plugin-sort-imports": "^4.2.1",
@@ -27,6 +27,7 @@
     "mocha": "^10.7.3",
     "prettier": "^3.7.4",
     "prettier-plugin-packagejson": "^2.5.20",
+    "rimraf": "^6.1.2",
     "typescript": "^5.3.0"
   },
   "peerDependencies": {

package/dist/lib/rules/no-else.js

@@ -1,27 +0,0 @@
-"use strict";
-// 禁止 else
-// else 表示"除当前条件外的所有可能"
-// 当状态集合未来扩展时, 依然会被包含在else分支里, 导致状态遗漏却无任何报错
-// 应当使用提早返回 或 switch + 穷尽检查
-Object.defineProperty(exports, "__esModule", { value: true });
-const rule = {
-    meta: {
-        type: 'problem',
-        docs: { description: '禁止使用 else 分支, 防止隐含的状态遗漏' },
-        messages: {
-            noElse: '禁止使用 else 分支。当条件状态扩展时, else 分支可能遗漏新的状态。请改用提前返回(early return)或 switch 语句',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        return {
-            IfStatement(node) {
-                if (node.alternate !== null) {
-                    context.report({ node: node.alternate, messageId: 'noElse' });
-                }
-            },
-        };
-    },
-};
-exports.default = rule;

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;