@lsby/eslint-plugin 0.0.26 → 0.0.28

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<'preferSwitch', []>;
 export default rule;

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

@@ -0,0 +1,87 @@
+"use strict";
+// 禁止对字面量枚举进行 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 typescript_1 = __importDefault(require("typescript"));
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: '禁止对字面量枚举进行 if-else 判断，应使用 switch' },
+        messages: { preferSwitch: '对字面量联合类型应使用 switch 语句而不是 if-else，以确保穷尽所有分支' },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            IfStatement(node) {
+                // 检查是否有最终的 else 分支（递归检查）
+                const hasFinalElse = hasFinalElseBranch(node);
+                if (!hasFinalElse)
+                    return;
+                // 检查是否是字面量对比（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.26",
+  "version": "0.0.28",
   "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;