@lsby/eslint-plugin 0.0.26 → 0.0.27

package/dist/index.js

@@ -4,16 +4,16 @@ 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_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_for_literal_enum_1 = __importDefault(require("./lib/rules/prefer-switch-for-literal-enum"));
 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-on-equality': no_else_on_equality_1.default,
+        'prefer-switch-for-literal-enum': prefer_switch_for_literal_enum_1.default,
         'no-switch-default': no_switch_default_1.default,
     },
 };

package/dist/lib/rules/prefer-let.js

@@ -1,17 +1,26 @@
 "use strict";
 // 永远使用let, 拒绝var和const, 并自动修复
-// 原因:
-// 1 抽象泄漏
-// const只约束原语值和指针不变, 不约束引用值本身不变
+//
+// # 原因:
+// ## 抽象泄漏
+// 使用const时, 通常我们**实际**想表达的意图是"该值不可变", 但const没有完全兑现这个意图
+// 设计上, const只约束原语值和指针不变, 不约束引用值本身不变
 // 使用者要搞懂什么可变什么不可变, 必须理解原语值和引用值的区别, 以及变量在内存上的机制
 // 这种"必须搞懂背后的原理才能正常使用"的情况是显然的抽象泄漏
-// 2 误导
+// ## 误导
 // 对于新人, 很容易被误解, 导致引用值被意外修改
-// 3 心智成本
+// ## 心智成本
 // 实际使用时, 即使是const声明值, 也必须确认其是否为引用类型, 若是则还是需要确认所有可能的修改
 // 这与let无异, 反而增加了心智成本
-// **错误的信息比没有信息更糟糕**
-// 替代:
+// ## 滑坡
+// **错误的信息比没有信息更糟糕, 不完全的限制比没有限制更糟糕**
+// 没有信息时人会自己去查, 而错误的信息会带来误导
+// 没有限制时人会考虑边界, 不完全的限制则导致要么完全不考虑边界(因为认为有兜底), 要么更小心的考虑边界(区分哪些是兜底, 哪些是没有兜底的)
+// 这不是加强培训能解决的, 人是不可信任和漏洞百出的, 必须通过形式约束才能让我们建立对代码的信心
+// 让我们想想墨菲定律: 任何可能出错的事情最终一定会出错
+// 如果我们放任使用这种很容易被误解的特性, 在大型项目中, 在足够长的时间后, 一定会出现我们不想看到的那种写法
+//
+// # 替代:
 // 如果真的需要表达不变, 应该使用类型等级的递归只读, 建模隐藏等方法
 // 这虽然复杂度更高, 但可以真正保证安全
 // 这也迫使程序员思考是否真的有必要这样设计, 而不是"随手一用", 提供一个"虚假的安全感"

package/dist/lib/rules/{no-else-on-equality.d.ts → prefer-switch-for-literal-enum.d.ts}

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

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

@@ -0,0 +1,143 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts = __importStar(require("typescript"));
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: '禁止对字面量枚举进行 if 判断并使用 else，应该使用 switch 来穷尽所有情况.' },
+        messages: { useSwitchForEnumLiteral: '检测到对字面量枚举的 if-else 判断，建议改用 switch 来穷尽所有情况.' },
+        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) {
+                    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' });
+                }
+            },
+        };
+    },
+};
+exports.default = rule;

package/package.json

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

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

@@ -1,178 +0,0 @@
-"use strict";
-// 禁止对于等于/不等于条件的 else 处理多种状态
-// 因为对于这些条件, else 表示"除给定状态外的所有可能"
-// 对于状态小于等于两个的条件, else 只会兜底一种情况, 这是正确的
-// 但如果状态继续增加, else 兜底必然匹配一个以上种状态
-// 此时 else 部分会默默吃掉新增状态却无任何提示, 这很容易造成意外的状态逻辑遗漏
-// 这种情况下应当使用提早返回(early return)或 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. 当状态扩张时, else 会隐匿地处理新状态, 容易造成状态逻辑遗漏. ',
-        },
-        messages: {
-            noElse: '禁止在非二值状态的等于/不等于条件中使用 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;
-                // Count distinct types in union
-                let count = 0;
-                for (const t of union.types) {
-                    count += countLiteralVariants(t);
-                }
-                return count;
-            }
-            // 布尔类型有 2 个值：true 和 false
-            if ((type.flags & ts.TypeFlags.Boolean) !== 0) {
-                return 2;
-            }
-            // 布尔字面量类型（true 或 false）
-            if ((type.flags & ts.TypeFlags.BooleanLiteral) !== 0) {
-                return 1;
-            }
-            // 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)) !== 0) {
-                return 1;
-            }
-            // 其他类型（如 number、string 等）认为是无限的
-            return Infinity;
-        }
-        /**
-         * 检查条件中是否包含等于或不等于操作符, 以及被比较的值
-         * 返回 [operand1, operand2] 或 null
-         */
-        function getEqualityOperands(node) {
-            if (node.type === 'BinaryExpression') {
-                const binExpr = node;
-                if (['===', '!==', '==', '!='].includes(binExpr.operator)) {
-                    return [binExpr.left, binExpr.right];
-                }
-                return null;
-            }
-            if (node.type === 'LogicalExpression') {
-                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 {
-            IfStatement(node) {
-                // 仅在 if 条件是等于或不等于的情况下, 禁止 else
-                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' });
-                        }
-                    }
-                }
-            },
-        };
-    },
-};
-exports.default = rule;