@foundbyte/eslint-plugin 1.1.4-alpha → 1.1.4-alpha.1

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

@@ -32,6 +32,14 @@ module.exports = {
     // 存储 any 类型使用的位置
     const anyUsages = []
 
+    /**
+     * 检查文件路径是否应该被排除
+     */
+    function shouldExcludeFile() {
+      // 不再排除任何文件，所有文件都检查
+      return false
+    }
+
     /**
      * 递归检查类型节点中的 any 类型
      */
@@ -79,25 +87,65 @@ module.exports = {
       }
     }
 
-    /**
-     * 检查 TSAnyKeyword 节点（显式 any 类型）
-     */
-    function checkTSAnyKeyword(node) {
-      anyUsages.push({
-        node,
-        type: 'explicit',
-      })
-    }
-
     /**
      * 检查类型注解中的 any 类型
      */
     function checkTypeAnnotation(node) {
+      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
+          }
+        }
+      }
+      
+      // 检查全局函数调用，如 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
+    }
+
     /**
      * 检查表达式是否可以推导类型
      */
@@ -126,12 +174,46 @@ module.exports = {
       
       // 函数调用：检查参数是否可以推导类型
       if (node.type === 'CallExpression') {
-        // 如果函数调用有参数，并且所有参数都可以推导类型，则认为可以推导返回类型
-        if (node.arguments && node.arguments.length > 0) {
-          return node.arguments.every(arg => canInferTypeFromExpression(arg))
+        // 检查是否是第三方库函数调用
+        if (isThirdPartyFunctionCall(node)) {
+          return true // 第三方库函数调用，假设可以推导类型
+        }
+        
+        // 检查是否是 Vue 响应式函数调用且有明确的类型参数
+        if (isTypedVueReactiveCall(node)) {
+          return true // 有明确的类型参数，可以推导类型
         }
-        // 没有参数的函数调用无法推导类型（如 ref()）
-        return false
+        
+        // 检查是否是 Vue 响应式函数（无论是否有类型参数）
+        if (isVueReactiveFunction(node)) {
+          // 对于 Vue 响应式函数调用，需要检查是否有参数可以推导类型
+          if (node.arguments && node.arguments.length > 0) {
+            // 如果有参数，并且所有参数都可以推导类型，则认为可以推导返回类型
+            return node.arguments.every(arg => canInferTypeFromExpression(arg))
+          }
+          
+          // 检查是否有类型参数（通过源代码文本检查）
+          // 由于 Vue SFC 文件中的 TypeScript 泛型可能没有被正确解析为 AST 节点，
+          // 我们通过检查源代码文本来判断是否有类型参数
+          const sourceCode = context.getSourceCode()
+          const callText = sourceCode.getText(node)
+          
+          // 检查调用文本中是否包含泛型类型参数（如 <string>）
+          const hasTypeParameters = callText.includes('<') && callText.includes('>')
+          
+          // 没有参数的 Vue 响应式函数调用，如果有类型参数，可以推导类型
+          // 如 ref<string>() 可以推导为 Ref<string | undefined>
+          if (hasTypeParameters) {
+            return true
+          }
+          
+          // 没有类型参数也没有参数的 Vue 响应式函数调用（如 ref()）无法推导类型
+          return false
+        }
+        
+        // 对于其他函数调用，假设可以推导类型
+        // 因为本地函数有明确的返回类型，TypeScript 可以推导
+        return true
       }
       
       // 属性访问通常可以推导类型（如 ref.value）
@@ -139,6 +221,11 @@ module.exports = {
         return true
       }
       
+      // 可选链表达式可以推导类型（如 spotArr?.find()）
+      if (node.type === 'ChainExpression') {
+        return true
+      }
+      
       // await 表达式可以推导类型（等待 Promise 的结果）
       if (node.type === 'AwaitExpression') {
         return true
@@ -148,10 +235,159 @@ module.exports = {
       return false
     }
 
+    /**
+     * 检查是否是第三方库函数调用
+     */
+    function isThirdPartyFunctionCall(node) {
+      if (node.type !== 'CallExpression') return false
+      
+      // 检查是否是内置函数
+      if (isBuiltInFunction(node)) {
+        return true
+      }
+      
+      // 获取当前文件的导入信息
+      const imports = getImportsForCurrentFile()
+      
+      // 检查标识符调用，如 isEqualWith(a, b)
+      if (node.callee.type === 'Identifier') {
+        const functionName = node.callee.name
+        const importInfo = imports.find(imp => imp.localName === functionName)
+        
+        if (importInfo) {
+          // 检查导入的模块是否在排除模式中
+          return isModuleExcluded(importInfo.modulePath)
+        }
+      }
+      
+      // 检查成员表达式调用，如 lodash.isEqualWith(a, b)
+      if (node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier') {
+        const objectName = node.callee.object.name
+        const importInfo = imports.find(imp => imp.localName === objectName)
+        
+        if (importInfo) {
+          // 检查导入的模块是否在排除模式中
+          return isModuleExcluded(importInfo.modulePath)
+        }
+      }
+      
+      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
+    }
+
+    /**
+     * 检查模块路径是否应该被排除
+     */
+    function isModuleExcluded(modulePath) {
+      // 检查是否是第三方模块（不以 ./ 或 ../ 开头）
+      const isThirdPartyModule = !modulePath.startsWith('./') && !modulePath.startsWith('../')
+      
+      if (isThirdPartyModule) {
+        return true // 所有第三方模块都排除
+      }
+      
+      return excludePatterns.some(pattern => {
+        if (pattern.includes('*')) {
+          const regex = new RegExp(pattern.replace(/\*/g, '.*'))
+          return regex.test(modulePath)
+        }
+        return modulePath.includes(pattern)
+      })
+    }
+
+    /**
+     * 获取当前文件的导入信息
+     */
+    function getImportsForCurrentFile() {
+      const imports = []
+      const programNode = context.getSourceCode().ast
+      
+      // 遍历所有导入声明
+      programNode.body.forEach(node => {
+        if (node.type === 'ImportDeclaration') {
+          const modulePath = node.source.value
+          
+          node.specifiers.forEach(specifier => {
+            if (specifier.type === 'ImportSpecifier') {
+              imports.push({
+                localName: specifier.local.name,
+                importedName: specifier.imported.name,
+                modulePath: modulePath
+              })
+            } else if (specifier.type === 'ImportDefaultSpecifier') {
+              imports.push({
+                localName: specifier.local.name,
+                importedName: 'default',
+                modulePath: modulePath
+              })
+            } else if (specifier.type === 'ImportNamespaceSpecifier') {
+              imports.push({
+                localName: specifier.local.name,
+                importedName: '*',
+                modulePath: modulePath
+              })
+            }
+          })
+        }
+      })
+      
+      return imports
+    }
+
     /**
      * 检查变量声明中的隐式 any 类型
      */
     function checkVariableDeclaration(node) {
+      if (shouldExcludeFile()) return
       // 遍历所有声明
       node.declarations.forEach(declaration => {
         if (declaration.id && declaration.id.type === 'Identifier') {
@@ -182,10 +418,14 @@ module.exports = {
                                                declaration.init.type === 'ArrowFunctionExpression'
                   
                   if (!isFunctionDeclaration) {
-                    anyUsages.push({
-                      node: declaration,
-                      type: 'implicit',
-                    })
+                    // 检查是否是简单的 Map/Set 实例化，这些可以通过上下文推导类型
+                    const isSimpleCollection = isSimpleCollectionInstantiation(declaration.init)
+                    if (!isSimpleCollection) {
+                      anyUsages.push({
+                        node: declaration,
+                        type: 'implicit',
+                      })
+                    }
                   }
                 }
               }
@@ -198,10 +438,114 @@ module.exports = {
       })
     }
 
+    /**
+     * 检查是否是 Vue 响应式函数（无论是否有类型参数）
+     */
+    function isVueReactiveFunction(node) {
+      if (!node || node.type !== 'CallExpression') return false
+      
+      // 检查是否是 ref() 或 reactive() 调用
+      if (node.callee.type === 'Identifier') {
+        const functionName = node.callee.name
+        const vueReactiveFunctions = ['ref', 'reactive', 'computed', 'watch', 'watchEffect']
+        
+        return vueReactiveFunctions.includes(functionName)
+      }
+      
+      return false
+    }
+
+    /**
+     * 检查是否是 Vue 响应式函数调用且有明确的类型参数
+     * 这个函数专门处理所有有类型参数的 Vue 响应式函数调用
+     */
+    function isTypedVueReactiveCall(node) {
+      if (!node || node.type !== 'CallExpression') return false
+      
+      // 检查是否是 Vue 响应式函数调用
+      if (node.callee.type === 'Identifier') {
+        const functionName = node.callee.name
+        const vueReactiveFunctions = ['ref', 'reactive', 'computed', 'watch', 'watchEffect']
+        
+        if (vueReactiveFunctions.includes(functionName)) {
+          // 检查是否有类型参数（TypeScript 泛型）
+          if (node.typeParameters && node.typeParameters.params && node.typeParameters.params.length > 0) {
+            return true // 有明确的类型参数
+          }
+        }
+      }
+      
+      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 类型
+     */
+    function checkFunctionDeclaration(node) {
+      if (shouldExcludeFile()) return
+      
+      // 检查函数返回类型中的 any
+      if (node.returnType && node.returnType.typeAnnotation) {
+        checkTypeNodeForAny(node.returnType.typeAnnotation, node)
+      }
+      
+      // 检查函数参数类型中的 any
+      if (node.params) {
+        node.params.forEach(param => {
+          if (param.typeAnnotation) {
+            checkTypeAnnotation(param)
+          }
+        })
+      }
+    }
+
+    /**
+     * 检查箭头函数中的 any 类型
+     */
+    function checkArrowFunctionExpression(node) {
+      if (shouldExcludeFile()) return
+      
+      // 检查箭头函数返回类型中的 any
+      if (node.returnType && node.returnType.typeAnnotation) {
+        checkTypeNodeForAny(node.returnType.typeAnnotation, node)
+      }
+      
+      // 检查箭头函数参数类型中的 any
+      if (node.params) {
+        node.params.forEach(param => {
+          if (param.typeAnnotation) {
+            checkTypeAnnotation(param)
+          }
+        })
+      }
+    }
+
     /**
      * 检查类型别名和接口中的 any 类型
      */
     function checkTypeDeclaration(node) {
+      if (shouldExcludeFile()) return
       if (node.typeAnnotation) {
         checkTypeNodeForAny(node.typeAnnotation, node)
       }
@@ -211,6 +555,7 @@ module.exports = {
      * 在文件结束时检查 any 类型使用次数
      */
     function checkAnyUsageCount() {
+      if (shouldExcludeFile()) return
       if (anyUsages.length > maxAnyCount) {
         // 报告第一个超出限制的 any 使用（第 maxAnyCount + 1 个）
         const firstExceededUsage = anyUsages[maxAnyCount]
@@ -226,8 +571,9 @@ module.exports = {
     }
 
     return {
-      TSAnyKeyword: checkTSAnyKeyword,
       VariableDeclaration: checkVariableDeclaration,
+      FunctionDeclaration: checkFunctionDeclaration,
+      ArrowFunctionExpression: checkArrowFunctionExpression,
       TSTypeAliasDeclaration: checkTypeDeclaration,
       TSInterfaceDeclaration: checkTypeDeclaration,
       'Program:exit': checkAnyUsageCount,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foundbyte/eslint-plugin",
-  "version": "1.1.4-alpha",
+  "version": "1.1.4-alpha.1",
   "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",