@lsby/eslint-plugin 0.0.27 → 0.0.28

package/dist/lib/rules/prefer-switch-for-literal-enum.d.ts

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

package/dist/lib/rules/prefer-switch-for-literal-enum.js

@@ -1,143 +1,87 @@
 "use strict";
-// 禁止对字面量枚举进行 if 判断并使用 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;
-    };
-})();
+// 禁止对字面量枚举进行 if-else 判断
+// 因为一旦字面量状态扩充, else 就会默默吃掉新增的状态
+// 当判断字面量枚举时, 应该使用 switch 来穷尽所有情况
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ts = __importStar(require("typescript"));
+const typescript_1 = __importDefault(require("typescript"));
 const rule = {
     meta: {
         type: 'suggestion',
-        docs: { description: '禁止对字面量枚举进行 if 判断并使用 else，应该使用 switch 来穷尽所有情况.' },
-        messages: { useSwitchForEnumLiteral: '检测到对字面量枚举的 if-else 判断，建议改用 switch 来穷尽所有情况.' },
+        docs: { description: '禁止对字面量枚举进行 if-else 判断，应使用 switch' },
+        messages: { preferSwitch: '对字面量联合类型应使用 switch 语句而不是 if-else，以确保穷尽所有分支' },
         schema: [],
     },
     defaultOptions: [],
     create(context) {
-        const parserServices = context.parserServices;
-        const typeChecker = parserServices?.program?.getTypeChecker();
-        /**
-         * 检查类型是否是字面量联合类型（枚举）
-         * 返回 true 如果是纯字面量联合类型，false 否则
-         * 排除布尔值类型（true | false 是语言的基本类型，不属于枚举）
-         */
-        function isLiteralUnionType(type) {
-            if (!typeChecker)
-                return false;
-            // 如果是布尔类型或只包含布尔字面量，排除掉
-            if ((type.flags & ts.TypeFlags.Boolean) !== 0) {
-                return false;
-            }
-            // 检查是否是联合类型
-            if ((type.flags & ts.TypeFlags.Union) === 0) {
-                return false;
-            }
-            const union = type;
-            // 联合类型中必须至少有 2 个成员
-            if (union.types.length < 2) {
-                return false;
-            }
-            // 检查所有类型成员是否都是字面量类型（只接受字符串和数字字面量，排除布尔值）
-            for (const t of union.types) {
-                const isStringLiteral = (t.flags & ts.TypeFlags.StringLiteral) !== 0;
-                const isNumberLiteral = (t.flags & ts.TypeFlags.NumberLiteral) !== 0;
-                // 注意：不接受布尔字面量，布尔值是语言基本类型
-                if (!isStringLiteral && !isNumberLiteral) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        /**
-         * 获取被比较的变量的类型
-         */
-        function getComparisonVariableType(expr) {
-            if (!typeChecker || !parserServices?.esTreeNodeToTSNodeMap) {
-                return null;
-            }
-            try {
-                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(expr);
-                if (!tsNode)
-                    return null;
-                if (expr.type === 'Identifier') {
-                    const symbol = typeChecker.getSymbolAtLocation(tsNode);
-                    if (symbol && symbol.valueDeclaration) {
-                        return typeChecker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
-                    }
-                }
-                return typeChecker.getTypeAtLocation(tsNode);
-            }
-            catch {
-                return null;
-            }
-        }
-        /**
-         * 检查条件是否是简单的等于比较
-         */
-        function getEqualityOperands(node) {
-            if (node.type === 'BinaryExpression') {
-                const binExpr = node;
-                if (['===', '!==', '==', '!='].includes(binExpr.operator)) {
-                    return [binExpr.left, binExpr.right];
-                }
-            }
-            return null;
-        }
         return {
             IfStatement(node) {
-                // 仅在 if 有 else 分支时检查
-                if (node.alternate === null) {
+                // 检查是否有最终的 else 分支（递归检查）
+                const hasFinalElse = hasFinalElseBranch(node);
+                if (!hasFinalElse)
                     return;
-                }
-                // 检查是否是等于/不等于比较
-                const operands = getEqualityOperands(node.test);
-                if (!operands) {
-                    return;
-                }
-                const [left, right] = operands;
-                // 尝试从两边获取类型，判断是否是字面量枚举
-                const leftType = getComparisonVariableType(left);
-                const rightType = getComparisonVariableType(right);
-                if (leftType && isLiteralUnionType(leftType)) {
-                    context.report({ node: node.alternate, messageId: 'useSwitchForEnumLiteral' });
-                    return;
-                }
-                if (rightType && isLiteralUnionType(rightType)) {
-                    context.report({ node: node.alternate, messageId: 'useSwitchForEnumLiteral' });
+                // 检查是否是字面量对比（test 是 BinaryExpression === 或 == 比较）
+                if (node.test.type === 'BinaryExpression' && (node.test.operator === '===' || node.test.operator === '==')) {
+                    const { left, right } = node.test;
+                    // 获取比较的变量（可能是左侧或右侧）
+                    const variableNode = left.type === 'Identifier' ? left : right.type === 'Identifier' ? right : null;
+                    if (!variableNode)
+                        return;
+                    // 使用 TypeScript 类型检查器检查类型
+                    const parserServices = context.parserServices;
+                    if (!parserServices || !parserServices.program)
+                        return;
+                    const typeChecker = parserServices.program.getTypeChecker();
+                    const tsNode = parserServices.esTreeNodeToTSNodeMap.get(variableNode);
+                    const variableType = typeChecker.getTypeAtLocation(tsNode);
+                    // 检查是否是字面量联合类型
+                    const isLiteralUnion = isLiteralUnionType(variableType, typeChecker);
+                    if (isLiteralUnion) {
+                        context.report({ node, messageId: 'preferSwitch' });
+                    }
                 }
             },
         };
     },
 };
+/**
+ * 检查 if-else 链是否有最终的 else 分支
+ */
+function hasFinalElseBranch(node) {
+    let current = node;
+    while (current.type === 'IfStatement') {
+        if (current.alternate === null) {
+            // 没有 else 分支
+            return false;
+        }
+        if (current.alternate.type !== 'IfStatement') {
+            // 有最终的 else 分支
+            return true;
+        }
+        // 继续检查 else if
+        current = current.alternate;
+    }
+    return false;
+}
+/**
+ * 检查类型是否是字面量联合类型
+ */
+function isLiteralUnionType(type, typeChecker) {
+    // 如果是联合类型，检查每个成员是否都是字面量类型
+    if (type.isUnion()) {
+        return type.types.every((memberType) => {
+            const flags = memberType.flags;
+            return ((flags & typescript_1.default.TypeFlags.StringLiteral) !== 0 ||
+                (flags & typescript_1.default.TypeFlags.NumberLiteral) !== 0 ||
+                (flags & typescript_1.default.TypeFlags.BooleanLiteral) !== 0);
+        });
+    }
+    // 如果是单个字面量类型，也认为是字面量联合（只有一个成员的联合）
+    const flags = type.flags;
+    return ((flags & typescript_1.default.TypeFlags.StringLiteral) !== 0 ||
+        (flags & typescript_1.default.TypeFlags.NumberLiteral) !== 0 ||
+        (flags & typescript_1.default.TypeFlags.BooleanLiteral) !== 0);
+}
 exports.default = rule;

package/package.json

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