@foundbyte/eslint-plugin 1.1.4-alpha.2 → 1.1.4-alpha.4

package/README.md

@@ -25,7 +25,7 @@ module.exports = {
     '@foundbyte/arrow-function-padding': 'error',
     '@foundbyte/no-initial-as-assertion': ['error', {
       excludeVariableAssertions: true,
-      excludeTypePatterns: ['^const$', '^[A-Z]$'],
+      excludeTypePatterns: ['^const$', '^[A-Z]$', '^unknown$'],
       excludeMethodReturns: ['parse', 'querySelector']
     }],
     '@foundbyte/hooks-arrow-function-only': 'error',

package/lib/rules/no-excessive-any.js

@@ -26,11 +26,16 @@ module.exports = {
   },
 
   create(context) {
-    const options = context.options[0] || {}
-    const maxAnyCount = options.maxAnyCount || 0
+const options = context.options[0] || {}
+const maxAnyCount = options.maxAnyCount || 0
 
-    // 存储 any 类型使用的位置
-    const anyUsages = []
+// 导入共享工具函数
+const { isBuiltInFunction, isSimpleCollectionInstantiation } = require('../utils/is-built-in-function')
+
+// 存储 any 类型使用的位置
+const anyUsages = []
+// 存储 any 类型的变量名
+const anyVariables = new Set()
 
     /**
      * 检查文件路径是否应该被排除
@@ -62,6 +67,13 @@ module.exports = {
         })
       }
 
+      // 检查类型参数实例化（如 ref<any[]> 中的 <any[]>）
+      if (node.type === 'TSTypeParameterInstantiation' && node.params) {
+        node.params.forEach(param => {
+          checkTypeNodeForAny(param, parentNode || node)
+        })
+      }
+
       // 检查联合类型和交叉类型
       if ((node.type === 'TSUnionType' || node.type === 'TSIntersectionType') && node.types) {
         node.types.forEach(type => {
@@ -85,6 +97,32 @@ module.exports = {
           checkTypeNodeForAny(node.returnType.typeAnnotation, node)
         }
       }
+
+      // 检查元组类型
+      if (node.type === 'TSTupleType' && node.elementTypes) {
+        node.elementTypes.forEach(elementType => {
+          checkTypeNodeForAny(elementType, node)
+        })
+      }
+
+      // 检查条件类型
+      if (node.type === 'TSConditionalType') {
+        checkTypeNodeForAny(node.checkType, node)
+        checkTypeNodeForAny(node.extendsType, node)
+        checkTypeNodeForAny(node.trueType, node)
+        checkTypeNodeForAny(node.falseType, node)
+      }
+
+      // 检查索引访问类型
+      if (node.type === 'TSIndexedAccessType') {
+        checkTypeNodeForAny(node.objectType, node)
+        checkTypeNodeForAny(node.indexType, node)
+      }
+
+      // 检查映射类型
+      if (node.type === 'TSMappedType' && node.typeAnnotation) {
+        checkTypeNodeForAny(node.typeAnnotation, node)
+      }
     }
 
     /**
@@ -94,58 +132,18 @@ module.exports = {
       if (shouldExcludeFile()) return
       if (node.typeAnnotation && node.typeAnnotation.typeAnnotation) {
         checkTypeNodeForAny(node.typeAnnotation.typeAnnotation, node)
-      }
-    }
-
-    /**
-     * 检查是否是内置函数
-     */
-    function isBuiltInFunction(node) {
-      if (node.type !== 'CallExpression') return false
-      
-      // 检查全局对象的方法调用，如 JSON.parse, Promise.all 等
-      if (node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier') {
-        const objectName = node.callee.object.name
-        
-        // 内置全局对象列表 - 这些对象的所有方法都认为是内置的
-        const builtInObjects = ['JSON', 'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean', 'Date', 'Math', 'RegExp', 'Map', 'Set', 'WeakMap', 'WeakSet']
-        
-        if (builtInObjects.includes(objectName)) {
-          // 对于这些内置对象，假设它们的所有方法都是内置的
-          // 这样可以避免维护庞大的方法列表
-          return true
-        }
-      }
-      
-      // 检查可选链调用，如 spotArr?.find()
-      if (node.callee.type === 'ChainExpression' && node.callee.expression.type === 'CallExpression') {
-        const chainCall = node.callee.expression
-        if (chainCall.callee.type === 'MemberExpression' && chainCall.callee.object.type === 'Identifier') {
-          const objectName = chainCall.callee.object.name
-          
-          // 内置全局对象列表
-          const builtInObjects = ['JSON', 'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean', 'Date', 'Math', 'RegExp', 'Map', 'Set', 'WeakMap', 'WeakSet']
-          
-          if (builtInObjects.includes(objectName)) {
-            // 对于这些内置对象，假设它们的所有方法都是内置的
-            return true
+        // 如果节点是标识符且有名称，检查类型注解中是否有 any
+        if (node.type === 'Identifier' && node.name) {
+          const typeAnnotation = node.typeAnnotation.typeAnnotation
+          if (typeAnnotation && typeAnnotation.type === 'TSAnyKeyword') {
+            // 记录 any 类型的变量名
+            anyVariables.add(node.name)
           }
         }
       }
-      
-      // 检查全局函数调用，如 parseInt, parseFloat, isNaN 等
-      if (node.callee.type === 'Identifier') {
-        const functionName = node.callee.name
-        const globalFunctions = [
-          'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'eval', 'encodeURI', 
-          'encodeURIComponent', 'decodeURI', 'decodeURIComponent', 'escape', 'unescape'
-        ]
-        return globalFunctions.includes(functionName)
-      }
-      
-      return false
     }
 
+
     /**
      * 检查表达式是否可以推导类型
      */
@@ -172,6 +170,21 @@ module.exports = {
         return true
       }
       
+      // 二元表达式可以推导类型（如 1 + 1）
+      if (node.type === 'BinaryExpression') {
+        return true
+      }
+      
+      // 一元表达式可以推导类型（如 -1, !true）
+      if (node.type === 'UnaryExpression') {
+        return true
+      }
+      
+      // 标识符通常可以推导类型（变量有类型注解）
+      if (node.type === 'Identifier') {
+        return true
+      }
+      
       // 函数调用：检查参数是否可以推导类型
       if (node.type === 'CallExpression') {
         // 检查是否是第三方库函数调用
@@ -231,6 +244,24 @@ module.exports = {
         return true
       }
       
+      // 条件表达式（三元表达式）可以推导类型
+      if (node.type === 'ConditionalExpression') {
+        // 检查条件和两个分支是否可以推导类型
+        const testCanInfer = canInferTypeFromExpression(node.test)
+        const consequentCanInfer = canInferTypeFromExpression(node.consequent)
+        const alternateCanInfer = canInferTypeFromExpression(node.alternate)
+        return testCanInfer && consequentCanInfer && alternateCanInfer
+      }
+      
+      // 模板字符串可以推导类型（字符串类型）
+      if (node.type === 'TemplateLiteral') {
+        // 检查模板字符串中的所有表达式是否可以推导类型
+        if (node.expressions && node.expressions.length > 0) {
+          return node.expressions.every(expr => canInferTypeFromExpression(expr))
+        }
+        return true
+      }
+      
       // 其他情况默认无法推导类型
       return false
     }
@@ -274,55 +305,6 @@ module.exports = {
       return false
     }
 
-    /**
-     * 检查是否是内置函数
-     */
-    function isBuiltInFunction(node) {
-      if (node.type !== 'CallExpression') return false
-      
-      // 检查全局对象的方法调用，如 JSON.parse, Promise.all 等
-      if (node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier') {
-        const objectName = node.callee.object.name
-        const propertyName = node.callee.property.type === 'Identifier' ? node.callee.property.name : ''
-        
-        // 内置全局对象列表
-        const builtInObjects = ['JSON', 'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean', 'Date', 'Math', 'RegExp', 'Map', 'Set', 'WeakMap', 'WeakSet']
-        
-        if (builtInObjects.includes(objectName)) {
-          // 对于这些内置对象，假设它们的所有方法都是内置的
-          // 这样可以避免维护庞大的方法列表
-          return true
-        }
-      }
-      
-      // 检查可选链调用，如 spotArr?.find()
-      if (node.callee.type === 'ChainExpression' && node.callee.expression.type === 'CallExpression') {
-        const chainCall = node.callee.expression
-        if (chainCall.callee.type === 'MemberExpression' && chainCall.callee.object.type === 'Identifier') {
-          const objectName = chainCall.callee.object.name
-          
-          // 内置全局对象列表
-          const builtInObjects = ['JSON', 'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean', 'Date', 'Math', 'RegExp', 'Map', 'Set', 'WeakMap', 'WeakSet']
-          
-          if (builtInObjects.includes(objectName)) {
-            // 对于这些内置对象，假设它们的所有方法都是内置的
-            return true
-          }
-        }
-      }
-      
-      // 检查全局函数调用，如 parseInt, parseFloat, isNaN 等
-      if (node.callee.type === 'Identifier') {
-        const functionName = node.callee.name
-        const globalFunctions = [
-          'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'eval', 'encodeURI', 
-          'encodeURIComponent', 'decodeURI', 'decodeURIComponent', 'escape', 'unescape'
-        ]
-        return globalFunctions.includes(functionName)
-      }
-      
-      return false
-    }
 
     /**
      * 检查模块路径是否应该被排除
@@ -421,6 +403,10 @@ module.exports = {
                       })
                     }
                   }
+                } else {
+                  // 如果可以推导类型，还需要检查初始值中是否包含显式 any
+                  // 例如：ref<any[]>() 中的 any[] 包含 any
+                  checkExpressionForAny(declaration.init)
                 }
               }
             }
@@ -472,26 +458,6 @@ module.exports = {
       return false
     }
 
-    /**
-     * 检查是否是简单的集合实例化（如 new Map(), new Set()）
-     * 这些可以通过上下文推导类型，不应该算作隐式 any
-     */
-    function isSimpleCollectionInstantiation(node) {
-      if (!node) return false
-      
-      // 检查 new Map() 或 new Set()
-      if (node.type === 'NewExpression') {
-        const calleeName = node.callee.type === 'Identifier' ? node.callee.name : ''
-        if (calleeName === 'Map' || calleeName === 'Set') {
-          // 检查是否有参数（无参数的 new Map() 或 new Set() 是简单的实例化）
-          if (!node.arguments || node.arguments.length === 0) {
-            return true
-          }
-        }
-      }
-      
-      return false
-    }
 
     /**
      * 检查函数声明中的 any 类型
@@ -533,6 +499,155 @@ module.exports = {
           }
         })
       }
+      
+      // 检查箭头函数体中的 any 类型变量使用
+      if (node.body) {
+        if (node.body.type === 'BlockStatement') {
+          // 遍历函数体中的语句
+          node.body.body.forEach(statement => {
+            // 检查返回语句
+            if (statement.type === 'ReturnStatement' && statement.argument) {
+              checkExpressionForAnyVariableUse(statement.argument)
+            }
+            // 检查表达式语句
+            else if (statement.type === 'ExpressionStatement') {
+              checkExpressionForAnyVariableUse(statement.expression)
+            }
+          })
+        } else {
+          // 简写箭头函数体（直接返回表达式）
+          checkExpressionForAnyVariableUse(node.body)
+        }
+      }
+    }
+
+    /**
+     * 检查表达式中的 any 类型
+     */
+    function checkExpressionForAny(node) {
+      if (!node) return
+      
+      // 检查函数调用中的类型参数
+      if (node.type === 'CallExpression') {
+        const sourceCode = context.getSourceCode()
+        const callText = sourceCode.getText(node)
+        
+        // 检查类型参数（泛型）
+        if (node.typeParameters) {
+          // 直接检查类型参数中的 any
+          if (node.typeParameters.params) {
+            node.typeParameters.params.forEach(param => {
+              checkTypeNodeForAny(param, node)
+            })
+          }
+        } else {
+          // 如果没有 typeParameters 节点，检查源代码文本中是否包含泛型类型参数
+          // 这可能是因为 Vue SFC 中的 TypeScript 泛型没有被正确解析
+          if (callText.includes('<') && callText.includes('>')) {
+            // 提取泛型类型参数部分
+            const match = callText.match(/<([^>]+)>/)
+            if (match) {
+              const typeParamText = match[1]
+              // 检查类型参数文本中是否包含 "any"
+              if (typeParamText.includes('any')) {
+                // 报告 any 使用
+                anyUsages.push({
+                  node: node,
+                  type: 'explicit',
+                })
+              }
+            }
+          }
+        }
+      }
+    }
+
+    /**
+     * 检查表达式中是否使用了 any 类型的变量
+     */
+    function checkExpressionForAnyVariableUse(node) {
+      if (!node) return
+      
+      // 检查标识符的使用
+      if (node.type === 'Identifier') {
+        if (anyVariables.has(node.name)) {
+          // 使用了 any 类型的变量，计数一次
+          anyUsages.push({
+            node: node,
+            type: 'explicit',
+          })
+        }
+        return // 标识符不需要进一步递归检查
+      }
+      
+      // 检查成员表达式（如 param.id）
+      if (node.type === 'MemberExpression') {
+        // 检查对象是否是标识符
+        if (node.object.type === 'Identifier') {
+          if (anyVariables.has(node.object.name)) {
+            // 使用了 any 类型的变量，计数一次
+            anyUsages.push({
+              node: node,
+              type: 'explicit',
+            })
+          }
+        } else {
+          // 如果对象不是标识符，递归检查对象
+          checkExpressionForAnyVariableUse(node.object)
+        }
+        // 检查属性（如果不是标识符）
+        if (node.property && node.property.type !== 'Identifier') {
+          checkExpressionForAnyVariableUse(node.property)
+        }
+        return // 成员表达式检查完成
+      }
+      
+      // 递归检查子表达式
+      if (node.type === 'CallExpression') {
+        if (node.callee) {
+          checkExpressionForAnyVariableUse(node.callee)
+        }
+        if (node.arguments) {
+          node.arguments.forEach(arg => {
+            checkExpressionForAnyVariableUse(arg)
+          })
+        }
+        return
+      }
+      
+      if (node.type === 'ReturnStatement' && node.argument) {
+        checkExpressionForAnyVariableUse(node.argument)
+        return
+      }
+      
+      if (node.type === 'ObjectExpression' && node.properties) {
+        node.properties.forEach(prop => {
+          if (prop.value) {
+            checkExpressionForAnyVariableUse(prop.value)
+          }
+        })
+        return
+      }
+      
+      if (node.type === 'ArrayExpression' && node.elements) {
+        node.elements.forEach(element => {
+          if (element) {
+            checkExpressionForAnyVariableUse(element)
+          }
+        })
+        return
+      }
+      
+      if (node.type === 'BinaryExpression') {
+        checkExpressionForAnyVariableUse(node.left)
+        checkExpressionForAnyVariableUse(node.right)
+        return
+      }
+      
+      if (node.type === 'UnaryExpression' && node.argument) {
+        checkExpressionForAnyVariableUse(node.argument)
+        return
+      }
     }
 
     /**
@@ -551,10 +666,10 @@ module.exports = {
     function checkAnyUsageCount() {
       if (shouldExcludeFile()) return
       if (anyUsages.length > maxAnyCount) {
-        // 报告第一个超出限制的 any 使用（第 maxAnyCount + 1 个）
-        const firstExceededUsage = anyUsages[maxAnyCount]
+        // 报告最后一个超出限制的 any 使用
+        const lastExceededUsage = anyUsages[anyUsages.length - 1]
         context.report({
-          node: firstExceededUsage.node,
+          node: lastExceededUsage.node,
           messageId: 'exceedMaxAnyCount',
           data: {
             maxAnyCount,

package/lib/utils/is-built-in-function.js

@@ -0,0 +1,78 @@
+/**
+ * 检查是否是内置函数
+ * @param {import('@typescript-eslint/types').TSESTree.CallExpression} node - 调用表达式节点
+ * @returns {boolean} 是否是内置函数
+ */
+function isBuiltInFunction(node) {
+  if (node.type !== 'CallExpression') return false
+  
+  // 检查全局对象的方法调用，如 JSON.parse, Promise.all 等
+  if (node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier') {
+    const objectName = node.callee.object.name
+    
+    // 内置全局对象列表 - 这些对象的所有方法都认为是内置的
+    const builtInObjects = ['JSON', 'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean', 'Date', 'Math', 'RegExp', 'Map', 'Set', 'WeakMap', 'WeakSet']
+    
+    if (builtInObjects.includes(objectName)) {
+      // 对于这些内置对象，假设它们的所有方法都是内置的
+      // 这样可以避免维护庞大的方法列表
+      return true
+    }
+  }
+  
+  // 检查可选链调用，如 spotArr?.find()
+  if (node.callee.type === 'ChainExpression' && node.callee.expression.type === 'CallExpression') {
+    const chainCall = node.callee.expression
+    if (chainCall.callee.type === 'MemberExpression' && chainCall.callee.object.type === 'Identifier') {
+      const objectName = chainCall.callee.object.name
+      
+      // 内置全局对象列表
+      const builtInObjects = ['JSON', 'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean', 'Date', 'Math', 'RegExp', 'Map', 'Set', 'WeakMap', 'WeakSet']
+      
+      if (builtInObjects.includes(objectName)) {
+        // 对于这些内置对象，假设它们的所有方法都是内置的
+        return true
+      }
+    }
+  }
+  
+  // 检查全局函数调用，如 parseInt, parseFloat, isNaN 等
+  if (node.callee.type === 'Identifier') {
+    const functionName = node.callee.name
+    const globalFunctions = [
+      'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'eval', 'encodeURI', 
+      'encodeURIComponent', 'decodeURI', 'decodeURIComponent', 'escape', 'unescape'
+    ]
+    return globalFunctions.includes(functionName)
+  }
+  
+  return false
+}
+
+/**
+ * 检查是否是简单的集合实例化（如 new Map(), new Set()）
+ * 这些可以通过上下文推导类型，不应该算作隐式 any
+ * @param {import('@typescript-eslint/types').TSESTree.NewExpression} node - new 表达式节点
+ * @returns {boolean} 是否是简单的集合实例化
+ */
+function isSimpleCollectionInstantiation(node) {
+  if (!node) return false
+  
+  // 检查 new Map() 或 new Set()
+  if (node.type === 'NewExpression') {
+    const calleeName = node.callee.type === 'Identifier' ? node.callee.name : ''
+    if (calleeName === 'Map' || calleeName === 'Set') {
+      // 检查是否有参数（无参数的 new Map() 或 new Set() 是简单的实例化）
+      if (!node.arguments || node.arguments.length === 0) {
+        return true
+      }
+    }
+  }
+  
+  return false
+}
+
+module.exports = {
+  isBuiltInFunction,
+  isSimpleCollectionInstantiation
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foundbyte/eslint-plugin",
-  "version": "1.1.4-alpha.2",
+  "version": "1.1.4-alpha.4",
   "description": "ESLint plugin for enforcing code style rules including arrow function padding, Vue script lines limit, and TypeScript type comment requirements",
   "main": "index.js",
   "types": "index.d.ts",