@lsby/eslint-plugin 0.0.28 → 0.0.30

package/dist/lib/rules/no-broken-link.js

@@ -5,7 +5,7 @@ const rule = {
     meta: {
         type: 'problem',
         docs: { description: '禁止在 JSDoc 注解中使用未定义的 {@link} 引用' },
-        messages: { undefinedLink: '{@link} 中的标识符 "{identifier}" 未定义' },
+        messages: { undefinedLink: '{@link} 中的标识符 "{{identifier}}" 未定义' },
         schema: [],
     },
     create(context) {

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

@@ -30,7 +30,7 @@ const rule = {
         type: 'suggestion',
         docs: { description: '禁止使用 const 和 var, 仅允许使用 let 声明变量' },
         fixable: 'code',
-        messages: { preferLet: '使用 let 代替 {kind}' },
+        messages: { preferLet: '使用 let 代替 {{kind}}' },
         schema: [],
     },
     defaultOptions: [],

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

@@ -18,27 +18,58 @@ const rule = {
     create(context) {
         return {
             IfStatement(node) {
-                // 检查是否有最终的 else 分支（递归检查）
-                const hasFinalElse = hasFinalElseBranch(node);
-                if (!hasFinalElse)
+                // 只检查不是某个 else if 的 if 语句（即顶层的 if）
+                const parent = node.parent;
+                if (parent && parent.type === 'IfStatement' && parent.alternate === node) {
+                    return;
+                }
+                // 检查是否有最终的 else 分支
+                if (!hasFinalElseBranch(node))
                     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 comparedSubject = getComparedSubject(left, right, parserServices, typeChecker);
+                    if (!comparedSubject)
+                        return;
+                    const tsNode = comparedSubject;
+                    // 尝试获取主体的声明类型而不仅仅是值的类型
+                    let variableType = typeChecker.getTypeAtLocation(tsNode);
+                    // 如果是标识符，尝试获取其符号的类型
+                    if (typescript_1.default.isIdentifier(tsNode)) {
+                        const symbol = typeChecker.getSymbolAtLocation(tsNode);
+                        if (symbol) {
+                            const declarations = symbol.declarations;
+                            if (declarations && declarations.length > 0) {
+                                // 尝试从变量声明获取类型
+                                const declaration = declarations[0];
+                                if (typescript_1.default.isVariableDeclaration(declaration) && declaration.type) {
+                                    variableType = typeChecker.getTypeFromTypeNode(declaration.type);
+                                }
+                            }
+                        }
+                    }
                     // 检查是否是字面量联合类型
-                    const isLiteralUnion = isLiteralUnionType(variableType, typeChecker);
-                    if (isLiteralUnion) {
+                    const literalTypeIds = getLiteralTypeIds(variableType);
+                    if (literalTypeIds.length === 0)
+                        return;
+                    // 检查 if-else 链是否混合使用了相等和其他比较操作符
+                    // 为了避免复杂性和误伤，混合使用的情况下放行
+                    if (hasMixedComparisonOperators(node))
+                        return;
+                    // 统计 if-else if 链中已经处理的字面量值（使用 Type.id 来区分）
+                    const handledTypeIds = new Set();
+                    collectHandledTypeIds(node, tsNode, typeChecker, parserServices, handledTypeIds);
+                    // 计算 else 分支实际处理的情况数
+                    const uncoveredCount = literalTypeIds.length - handledTypeIds.size;
+                    // 只有当 else 覆盖多于一种情况时才报错
+                    if (uncoveredCount > 1) {
                         context.report({ node, messageId: 'preferSwitch' });
                     }
                 }
@@ -52,36 +83,167 @@ const rule = {
 function hasFinalElseBranch(node) {
     let current = node;
     while (current.type === 'IfStatement') {
-        if (current.alternate === null) {
-            // 没有 else 分支
+        if (current.alternate === null)
             return false;
+        if (current.alternate.type !== 'IfStatement')
+            return true;
+        current = current.alternate;
+    }
+    return false;
+}
+/**
+ * 检查 if-else if 链是否混合使用了相等操作符（=== 或 ==）和其他比较操作符（>, <, >=, <=, !=, !==）
+ * 如果混合使用，为了避免复杂的逻辑分析和误伤，返回 true（应该放行）
+ */
+function hasMixedComparisonOperators(node) {
+    let hasEqualityOperator = false;
+    let hasOtherOperator = false;
+    let current = node;
+    while (current) {
+        if (current.test.type === 'BinaryExpression') {
+            const operator = current.test.operator;
+            // 相等操作符
+            if (operator === '===' || operator === '==') {
+                hasEqualityOperator = true;
+            }
+            // 其他比较操作符
+            if (operator === '>' ||
+                operator === '<' ||
+                operator === '>=' ||
+                operator === '<=' ||
+                operator === '!=' ||
+                operator === '!==') {
+                hasOtherOperator = true;
+            }
         }
-        if (current.alternate.type !== 'IfStatement') {
-            // 有最终的 else 分支
+        // 如果发现了混合使用，立即返回
+        if (hasEqualityOperator && hasOtherOperator) {
             return true;
         }
-        // 继续检查 else if
-        current = current.alternate;
+        // 移动到 else if
+        if (current.alternate && current.alternate.type === 'IfStatement') {
+            current = current.alternate;
+        }
+        else {
+            break;
+        }
     }
     return false;
 }
 /**
- * 检查类型是否是字面量联合类型
+ * 检查是否是字面量类型（字符串、数字或布尔字面量）
  */
-function isLiteralUnionType(type, typeChecker) {
-    // 如果是联合类型，检查每个成员是否都是字面量类型
+function isLiteralType(type) {
+    return type.isStringLiteral() || type.isNumberLiteral() || !!(type.flags & typescript_1.default.TypeFlags.BooleanLiteral);
+}
+/**
+ * 从二元表达式的左右两侧提取被比较的"主体"（非字面量值的那一侧）
+ * 支持任意表达式：Identifier, MemberExpression, CallExpression, TSAsExpression 等
+ * 也支持常量引用（如 const X = 'a' as const，然后 if (y === X)）
+ * 返回 TypeScript AST 节点，如果两侧都是字面量或无法确定则返回 null
+ */
+function getComparedSubject(left, right, parserServices, typeChecker) {
+    const tsLeft = parserServices.esTreeNodeToTSNodeMap.get(left);
+    const tsRight = parserServices.esTreeNodeToTSNodeMap.get(right);
+    // 首先检查 AST 节点类型，优先识别直接的字面量
+    const isLeftAstLiteral = left.type === 'Literal';
+    const isRightAstLiteral = right.type === 'Literal';
+    // 如果一侧是 AST 字面量，另一侧不是，直接返回
+    if (isLeftAstLiteral && !isRightAstLiteral) {
+        return tsRight;
+    }
+    else if (!isLeftAstLiteral && isRightAstLiteral) {
+        return tsLeft;
+    }
+    // 如果都不是 AST 字面量，尝试用类型系统判断（支持 as const 常量）
+    if (!isLeftAstLiteral && !isRightAstLiteral) {
+        const leftType = typeChecker.getTypeAtLocation(tsLeft);
+        const rightType = typeChecker.getTypeAtLocation(tsRight);
+        const isLeftLiteralType = isLiteralType(leftType);
+        const isRightLiteralType = isLiteralType(rightType);
+        // 只有当一侧是字面量类型，另一侧不是时，才能继续
+        if (isLeftLiteralType && !isRightLiteralType) {
+            return tsRight;
+        }
+        else if (!isLeftLiteralType && isRightLiteralType) {
+            return tsLeft;
+        }
+    }
+    return null;
+}
+/**
+ * 比较两个 TypeScript AST 节点是否代表同一个主体
+ * 支持：
+ * - Identifier：变量名相同
+ * - MemberExpression：对象和属性都相同
+ * - CallExpression：函数和参数都相同
+ * - TSAsExpression：忽略类型断言，比较内层表达式
+ * 等等
+ */
+function isSameSubject(node1, node2, typeChecker) {
+    // 简单的情况：节点文本相同
+    if (node1.getText() === node2.getText()) {
+        return true;
+    }
+    // 如果两个节点的符号相同，认为它们代表同一个主体
+    if (typescript_1.default.isIdentifier(node1) && typescript_1.default.isIdentifier(node2)) {
+        const symbol1 = typeChecker.getSymbolAtLocation(node1);
+        const symbol2 = typeChecker.getSymbolAtLocation(node2);
+        if (symbol1 && symbol2 && symbol1 === symbol2) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 获取字面量联合类型的所有 Type.id
+ */
+function getLiteralTypeIds(type) {
+    const typeIds = [];
     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);
+        type.types.forEach((memberType) => {
+            if (isLiteralType(memberType)) {
+                typeIds.push(memberType.id);
+            }
         });
     }
-    // 如果是单个字面量类型，也认为是字面量联合（只有一个成员的联合）
-    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);
+    else {
+        if (isLiteralType(type)) {
+            typeIds.push(type.id);
+        }
+    }
+    return typeIds;
+}
+/**
+ * 递归收集 if-else if 链中已经处理的字面量值（使用 Type.id 来区分）
+ */
+function collectHandledTypeIds(node, comparedSubject, typeChecker, parserServices, handledTypeIds) {
+    // 检查当前 if 的条件
+    if (node.test.type === 'BinaryExpression' && (node.test.operator === '===' || node.test.operator === '==')) {
+        const { left, right } = node.test;
+        // 判断哪一侧是比较的主体，哪一侧是值
+        let valueNode = null;
+        const tsLeft = parserServices.esTreeNodeToTSNodeMap.get(left);
+        const tsRight = parserServices.esTreeNodeToTSNodeMap.get(right);
+        if (isSameSubject(tsLeft, comparedSubject, typeChecker)) {
+            valueNode = right;
+        }
+        else if (isSameSubject(tsRight, comparedSubject, typeChecker)) {
+            valueNode = left;
+        }
+        if (valueNode) {
+            // 获取值表达式的 TypeScript 类型
+            const tsValueNode = parserServices.esTreeNodeToTSNodeMap.get(valueNode);
+            const valueType = typeChecker.getTypeAtLocation(tsValueNode);
+            // 如果是字面量类型，添加其 id
+            if (isLiteralType(valueType)) {
+                handledTypeIds.add(valueType.id);
+            }
+        }
+    }
+    // 递归检查 else if
+    if (node.alternate && node.alternate.type === 'IfStatement') {
+        collectHandledTypeIds(node.alternate, comparedSubject, typeChecker, parserServices, handledTypeIds);
+    }
 }
 exports.default = rule;

package/package.json

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