@lsby/eslint-plugin 0.0.19 → 0.0.21

package/dist/index.js

@@ -4,7 +4,6 @@ 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"));
@@ -14,7 +13,6 @@ module.exports = {
         '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,
     },

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

@@ -1,37 +1,164 @@
 "use strict";
 // 禁止 else（当条件是等于或不等于时）
 // 对于等于/不等于的条件判断，else 表示"除当前条件外的所有可能"
-// 当状态集合未来扩展时, 依然会被包含在else分支里, 导致状态遗漏却无任何报错
+// 当状态集合未来扩展到多于2个时, else部分会默默吃掉新增状态却无任何提示
+// 这很容易造成意外的状态遗漏
 // 应当使用提早返回 或 switch + 穷尽检查
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+const ts = __importStar(require("typescript"));
 const rule = {
     meta: {
         type: 'problem',
         docs: { description: '当条件是等于或不等于时，禁止使用 else 分支，防止隐含的状态遗漏' },
         messages: {
-            noElse: '禁止在等于/不等于条件下使用 else 分支。当条件状态扩展时, else 分支可能遗漏新的状态。请改用提前返回(early return)或 switch 语句',
+            noElse: '禁止在等于/不等于条件下使用 else 分支。当条件状态扩展到多于2个时, else部分会默默吃掉新增状态却无任何提示。请改用提前返回(early return)或 switch 语句',
         },
         schema: [],
     },
     defaultOptions: [],
     create(context) {
+        const parserServices = context.parserServices;
+        const typeChecker = parserServices?.program?.getTypeChecker();
+        /**
+         * 计算类型中的字面量值个数
+         */
+        function countLiteralVariants(type) {
+            // 先检查联合类型，因为它可能包含其他标志
+            if ((type.flags & ts.TypeFlags.Union) !== 0) {
+                const union = type;
+                return union.types.length;
+            }
+            // 布尔类型有 2 个值：true 和 false
+            if ((type.flags & ts.TypeFlags.Boolean) !== 0) {
+                return 2;
+            }
+            // null 类型（1 个值）
+            if ((type.flags & ts.TypeFlags.Null) !== 0) {
+                return 1;
+            }
+            // undefined 类型（1 个值）
+            if ((type.flags & ts.TypeFlags.Undefined) !== 0) {
+                return 1;
+            }
+            // 字面量类型
+            if ((type.flags & (ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral | ts.TypeFlags.BooleanLiteral)) !==
+                0) {
+                return 1;
+            }
+            // 其他类型（如 number、string 等）认为是无限的
+            return Infinity;
+        }
         /**
-         * 检查条件中是否包含等于或不等于操作符
+         * 检查条件中是否包含等于或不等于操作符，以及被比较的值
+         * 返回 [operand1, operand2] 或 null
          */
-        function hasEqualityOperator(node) {
+        function getEqualityOperands(node) {
             if (node.type === 'BinaryExpression') {
-                return ['===', '!==', '==', '!='].includes(node.operator);
+                const binExpr = node;
+                if (['===', '!==', '==', '!='].includes(binExpr.operator)) {
+                    return [binExpr.left, binExpr.right];
+                }
+                return null;
             }
             if (node.type === 'LogicalExpression') {
-                return hasEqualityOperator(node.left) || hasEqualityOperator(node.right);
+                const left = getEqualityOperands(node.left);
+                if (left)
+                    return left;
+                return getEqualityOperands(node.right);
+            }
+            return null;
+        }
+        /**
+         * 检查是否应该允许 else（状态数 ≤ 2）
+         * 返回 true 表示允许 else，false 表示不允许
+         */
+        function shouldAllowElse(leftExpr, rightExpr) {
+            if (!typeChecker || !parserServices?.esTreeNodeToTSNodeMap) {
+                // 无法获取类型信息时，按原始规则：不允许 else
+                return false;
+            }
+            try {
+                // 获取 TypeScript 节点
+                const leftNode = parserServices.esTreeNodeToTSNodeMap.get(leftExpr);
+                const rightNode = parserServices.esTreeNodeToTSNodeMap.get(rightExpr);
+                if (!leftNode || !rightNode) {
+                    // 无法映射节点时，按原始规则：不允许 else
+                    return false;
+                }
+                // 获取两个操作数的类型
+                let leftType = typeChecker.getTypeAtLocation(leftNode);
+                let rightType = typeChecker.getTypeAtLocation(rightNode);
+                // 对于标识符，尝试获取声明的类型
+                if (leftExpr.type === 'Identifier') {
+                    const leftSymbol = typeChecker.getSymbolAtLocation(leftNode);
+                    if (leftSymbol && leftSymbol.valueDeclaration) {
+                        leftType = typeChecker.getTypeOfSymbolAtLocation(leftSymbol, leftSymbol.valueDeclaration);
+                    }
+                }
+                if (rightExpr.type === 'Identifier') {
+                    const rightSymbol = typeChecker.getSymbolAtLocation(rightNode);
+                    if (rightSymbol && rightSymbol.valueDeclaration) {
+                        rightType = typeChecker.getTypeOfSymbolAtLocation(rightSymbol, rightSymbol.valueDeclaration);
+                    }
+                }
+                // 计算每边的字面量值个数
+                const leftCount = countLiteralVariants(leftType);
+                const rightCount = countLiteralVariants(rightType);
+                // 只有当两边都是有限的且都 ≤ 2 个状态时，才允许 else
+                const bothFinite = isFinite(leftCount) && isFinite(rightCount);
+                const allow = bothFinite && leftCount <= 2 && rightCount <= 2;
+                return allow;
+            }
+            catch {
+                // 如果出错，按原始规则：不允许 else
+                return false;
             }
-            return false;
         }
         return {
             IfStatement(node) {
                 // 仅在 if 条件是等于或不等于的情况下，禁止 else
-                if (node.alternate !== null && hasEqualityOperator(node.test)) {
-                    context.report({ node: node.alternate, messageId: 'noElse' });
+                if (node.alternate !== null) {
+                    const operands = getEqualityOperands(node.test);
+                    if (operands) {
+                        const [left, right] = operands;
+                        // 检查是否应该允许 else（基于类型的字面量值个数）
+                        if (!shouldAllowElse(left, right)) {
+                            context.report({ node: node.alternate, messageId: 'noElse' });
+                        }
+                    }
                 }
             },
         };

package/package.json

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

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

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

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

@@ -1,57 +0,0 @@
-"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;