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

package/README.md

@@ -25,7 +25,7 @@ module.exports = {
     '@foundbyte/arrow-function-padding': 'error',
     '@foundbyte/no-initial-as-assertion': ['error', {
       excludeVariableAssertions: true,
-      excludeTypePatterns: ['^const$'],
+      excludeTypePatterns: ['^const$', '^[A-Z]$'],
       excludeMethodReturns: ['parse', 'querySelector']
     }],
     '@foundbyte/hooks-arrow-function-only': 'error',
@@ -47,12 +47,105 @@ module.exports = {
         }
       ]
     }],
+    '@foundbyte/no-excessive-any': ['error', { maxAnyCount: 5 }],
   },
 }
 ```
 
 ## 规则列表与配置示例
 
+### no-excessive-any
+
+限制 `any` 类型的使用次数，包括：
+- 显式 `any` 类型
+- 隐式 `any` 类型（没有类型注解且无法推导类型的变量）
+- 泛型类型中的 `any`（如 `Ref<any>`, `Promise<any>`, `any[]` 等）
+
+**配置示例：**
+```javascript
+// 基本用法 - 限制 any 类型最多使用 5 次
+'@foundbyte/no-excessive-any': ['error', { maxAnyCount: 5 }]
+
+// 严格模式 - 禁止使用 any 类型
+'@foundbyte/no-excessive-any': ['error', { maxAnyCount: 0 }]
+
+// 宽松模式 - 允许最多 10 次 any 类型使用
+'@foundbyte/no-excessive-any': ['error', { maxAnyCount: 10 }]
+```
+
+**检测范围：**
+- 显式 `any` 类型：`const a: any = 1`
+- 隐式 `any` 类型：
+  - 没有初始值的变量声明：`const a`
+  - 没有参数的函数调用：`const a = ref()`
+- 泛型类型中的 `any`：
+  - `Ref<any>`, `Promise<any>`, `Array<any>`
+  - `any[]`, `string | any`, `T extends any`
+  - 类型别名和接口中的 `any`
+
+**智能类型推导：**
+以下情况不计入 any 使用：
+- 有初始值的变量：`const a = 1`, `const b = ref(60)`
+- 对象字面量：`const obj = { name: 'test' }`
+- 数组字面量：`const arr = [1, 2, 3]`
+- 函数表达式和箭头函数：`const fn = () => {}`
+- 有参数的函数调用：`const a = useRegex(phoneNum, 'phone-number')`
+- 属性访问：`const value = ref.value`
+- 异步函数调用：`const res = await ssoMobileAuth(...)`
+
+**示例：**
+```typescript
+// ✅ 正确 - 当 maxAnyCount 为 3 时
+const a: any = 1
+const b: any = 'hello'
+const c = ref() // 隐式 any
+
+// ❌ 错误 - 当 maxAnyCount 为 3 时，第 4 次 any 使用会报错
+const a: any = 1
+const b: any = 'hello'
+const c = ref() // 隐式 any
+const d: any = true // 错误：any 类型使用次数不能超过 3 次，当前使用了 4 次
+
+// ✅ 正确 - 使用具体类型
+const a: number = 1
+const b: string = 'hello'
+const c: number = 123
+const d: boolean = true
+
+// ✅ 正确 - 可以推导类型的情况不计入 any 使用
+const time = ref(60) // 有数字字面量参数，可以推导类型
+const messages = { noMore: 'text' } // 对象字面量，可以推导类型
+const fn = () => {} // 函数表达式，可以推导类型
+const res = await ssoMobileAuth({ nonce: nonce.value }) // 异步函数调用，可以推导类型
+
+// ❌ 错误 - 无法推导类型的隐式 any
+const a // 没有初始值
+const b = ref() // 没有参数的函数调用
+const c: Ref<any> = ref() // 显式 any 类型
+
+// ❌ 错误 - 泛型类型中的 any
+type MyType<T = any> = T
+interface MyInterface {
+  value: any
+  ref: Ref<any>
+  array: any[]
+  union: string | any
+  generic: Promise<any>
+}
+```
+
+**配置选项：**
+
+- `maxAnyCount` (number, 默认 0): 允许的 `any` 类型最大使用次数
+  - 设置为 0 表示完全禁止使用 `any` 类型
+  - 设置为正整数表示允许的最大次数
+
+**注意：**
+- 该规则统计文件中所有 `any` 类型的使用，包括显式和隐式
+- 规则会智能识别可以类型推导的情况，避免过度检测
+- 建议在 TypeScript 项目中设置合理的限制，鼓励使用具体类型
+- 对于遗留代码迁移，可以设置较高的限制值，然后逐步减少
+
 ### no-initial-as-assertion
 
 禁止在初始变量定义时使用 `as` 类型断言，强制使用显式类型注解。

package/index.js

@@ -5,6 +5,7 @@ const hooksExportLimitRule = require('./lib/rules/hooks-export-limit')
 const hooksArrowFunctionOnlyRule = require('./lib/rules/hooks-arrow-function-only')
 const tagAttributeRestrictionRule = require('./lib/rules/tag-attribute-restriction')
 const noInitialAsAssertionRule = require('./lib/rules/no-initial-as-assertion')
+const noExcessiveAnyRule = require('./lib/rules/no-excessive-any')
 
 module.exports = {
   rules: {
@@ -15,5 +16,6 @@ module.exports = {
     'hooks-arrow-function-only': hooksArrowFunctionOnlyRule,
     'tag-attribute-restriction': tagAttributeRestrictionRule,
     'no-initial-as-assertion': noInitialAsAssertionRule,
+    'no-excessive-any': noExcessiveAnyRule,
   },
 }

package/lib/rules/index.d.ts

@@ -5,6 +5,7 @@ export { VueScriptLinesLimitOptions } from './vue-script-lines-limit'
 export { HooksArrowFunctionOnlyOptions } from './hooks-arrow-function-only'
 export { TagAttributeRestrictionOptions } from './tag-attribute-restriction'
 export { NoInitialAsAssertionOptions } from './no-initial-as-assertion'
+export { NoExcessiveAnyOptions } from './no-excessive-any'
 
 import { Rule } from 'eslint'
 
@@ -47,6 +48,11 @@ export interface Rules {
    */
   'no-initial-as-assertion': Rule.RuleModule
 
+  /**
+   * 限制 any 类型的使用次数
+   */
+  'no-excessive-any': Rule.RuleModule
+
   /**
    * 索引签名，用于兼容 ESLint 插件类型
    */

package/lib/rules/no-excessive-any.d.ts

@@ -0,0 +1,9 @@
+import { Rule } from 'eslint'
+
+export interface NoExcessiveAnyOptions {
+  maxAnyCount?: number
+}
+
+declare const rule: Rule.RuleModule
+
+export default rule

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

@@ -0,0 +1,582 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: '限制 any 类型的使用次数',
+      category: 'Best Practices',
+      recommended: false,
+    },
+    fixable: null,
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          maxAnyCount: {
+            type: 'number',
+            minimum: 0,
+            description: '允许的 any 类型最大使用次数',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      exceedMaxAnyCount: 'any 类型使用次数不能超过 {{maxAnyCount}} 次，当前使用了 {{currentCount}} 次',
+    },
+  },
+
+  create(context) {
+    const options = context.options[0] || {}
+    const maxAnyCount = options.maxAnyCount || 0
+
+    // 存储 any 类型使用的位置
+    const anyUsages = []
+
+    /**
+     * 检查文件路径是否应该被排除
+     */
+    function shouldExcludeFile() {
+      // 不再排除任何文件，所有文件都检查
+      return false
+    }
+
+    /**
+     * 递归检查类型节点中的 any 类型
+     */
+    function checkTypeNodeForAny(node, parentNode = null) {
+      if (!node) return
+
+      // 检查显式 any 类型
+      if (node.type === 'TSAnyKeyword') {
+        anyUsages.push({
+          node: parentNode || node,
+          type: 'explicit',
+        })
+        return
+      }
+
+      // 检查泛型类型参数中的 any
+      if (node.type === 'TSTypeReference' && node.typeParameters) {
+        node.typeParameters.params.forEach(param => {
+          checkTypeNodeForAny(param, node)
+        })
+      }
+
+      // 检查联合类型和交叉类型
+      if ((node.type === 'TSUnionType' || node.type === 'TSIntersectionType') && node.types) {
+        node.types.forEach(type => {
+          checkTypeNodeForAny(type, node)
+        })
+      }
+
+      // 检查数组类型
+      if (node.type === 'TSArrayType' && node.elementType) {
+        checkTypeNodeForAny(node.elementType, node)
+      }
+
+      // 检查函数类型
+      if (node.type === 'TSFunctionType' && node.parameters) {
+        node.parameters.forEach(param => {
+          if (param.typeAnnotation) {
+            checkTypeNodeForAny(param.typeAnnotation.typeAnnotation, param)
+          }
+        })
+        if (node.returnType) {
+          checkTypeNodeForAny(node.returnType.typeAnnotation, node)
+        }
+      }
+    }
+
+    /**
+     * 检查类型注解中的 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
+    }
+
+    /**
+     * 检查表达式是否可以推导类型
+     */
+    function canInferTypeFromExpression(node) {
+      if (!node) return false
+      
+      // 字面量可以直接推导类型
+      if (node.type === 'Literal') {
+        return true
+      }
+      
+      // 对象字面量可以推导类型
+      if (node.type === 'ObjectExpression') {
+        return true
+      }
+      
+      // 数组字面量可以推导类型
+      if (node.type === 'ArrayExpression') {
+        return true
+      }
+      
+      // 函数表达式和箭头函数可以推导类型（函数本身有类型）
+      if (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+        return true
+      }
+      
+      // 函数调用：检查参数是否可以推导类型
+      if (node.type === 'CallExpression') {
+        // 检查是否是第三方库函数调用
+        if (isThirdPartyFunctionCall(node)) {
+          return true // 第三方库函数调用，假设可以推导类型
+        }
+        
+        // 检查是否是 Vue 响应式函数调用且有明确的类型参数
+        if (isTypedVueReactiveCall(node)) {
+          return true // 有明确的类型参数，可以推导类型
+        }
+        
+        // 检查是否是 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）
+      if (node.type === 'MemberExpression') {
+        return true
+      }
+      
+      // 可选链表达式可以推导类型（如 spotArr?.find()）
+      if (node.type === 'ChainExpression') {
+        return true
+      }
+      
+      // await 表达式可以推导类型（等待 Promise 的结果）
+      if (node.type === 'AwaitExpression') {
+        return true
+      }
+      
+      // 其他情况默认无法推导类型
+      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') {
+          // 检查变量声明是否没有类型注解
+          if (declaration.id.typeAnnotation === undefined) {
+            // 检查是否是函数参数
+            const isFunctionParam = node.parent && 
+              (node.parent.type === 'FunctionDeclaration' || 
+               node.parent.type === 'FunctionExpression' ||
+               node.parent.type === 'ArrowFunctionExpression')
+            
+            if (!isFunctionParam) {
+              // 检查是否有初始值可以推导类型
+              const hasInitializer = declaration.init !== undefined && declaration.init !== null
+              
+              // 如果变量没有初始值，则认为是隐式 any
+              if (!hasInitializer) {
+                anyUsages.push({
+                  node: declaration,
+                  type: 'implicit',
+                })
+              } else if (declaration.init) {
+                // 检查初始值是否可以推导类型
+                const canInferType = canInferTypeFromExpression(declaration.init)
+                if (!canInferType) {
+                  // 额外检查：确保不是函数声明
+                  const isFunctionDeclaration = declaration.init.type === 'FunctionExpression' || 
+                                               declaration.init.type === 'ArrowFunctionExpression'
+                  
+                  if (!isFunctionDeclaration) {
+                    // 检查是否是简单的 Map/Set 实例化，这些可以通过上下文推导类型
+                    const isSimpleCollection = isSimpleCollectionInstantiation(declaration.init)
+                    if (!isSimpleCollection) {
+                      anyUsages.push({
+                        node: declaration,
+                        type: 'implicit',
+                      })
+                    }
+                  }
+                }
+              }
+            }
+          } else if (declaration.id.typeAnnotation) {
+            // 检查类型注解中的 any
+            checkTypeAnnotation(declaration.id)
+          }
+        }
+      })
+    }
+
+    /**
+     * 检查是否是 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)
+      }
+    }
+
+    /**
+     * 在文件结束时检查 any 类型使用次数
+     */
+    function checkAnyUsageCount() {
+      if (shouldExcludeFile()) return
+      if (anyUsages.length > maxAnyCount) {
+        // 报告第一个超出限制的 any 使用（第 maxAnyCount + 1 个）
+        const firstExceededUsage = anyUsages[maxAnyCount]
+        context.report({
+          node: firstExceededUsage.node,
+          messageId: 'exceedMaxAnyCount',
+          data: {
+            maxAnyCount,
+            currentCount: anyUsages.length,
+          },
+        })
+      }
+    }
+
+    return {
+      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.2",
+  "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",

package/types.d.ts

@@ -1,2 +1,2 @@
 // 导出所有规则配置类型
-export type { ArrowFunctionPaddingOptions, HooksExportLimitOptions, TypeCommentRequirementOptions, VueScriptLinesLimitOptions, HooksArrowFunctionOnlyOptions } from './lib/rules'
+export type { ArrowFunctionPaddingOptions, HooksExportLimitOptions, TypeCommentRequirementOptions, VueScriptLinesLimitOptions, HooksArrowFunctionOnlyOptions, NoExcessiveAnyOptions } from './lib/rules'