@foundbyte/eslint-plugin 1.1.2 → 1.1.4-alpha

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,236 @@
+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 = []
+
+    /**
+     * 递归检查类型节点中的 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)
+        }
+      }
+    }
+
+    /**
+     * 检查 TSAnyKeyword 节点（显式 any 类型）
+     */
+    function checkTSAnyKeyword(node) {
+      anyUsages.push({
+        node,
+        type: 'explicit',
+      })
+    }
+
+    /**
+     * 检查类型注解中的 any 类型
+     */
+    function checkTypeAnnotation(node) {
+      if (node.typeAnnotation && node.typeAnnotation.typeAnnotation) {
+        checkTypeNodeForAny(node.typeAnnotation.typeAnnotation, node)
+      }
+    }
+
+    /**
+     * 检查表达式是否可以推导类型
+     */
+    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 (node.arguments && node.arguments.length > 0) {
+          return node.arguments.every(arg => canInferTypeFromExpression(arg))
+        }
+        // 没有参数的函数调用无法推导类型（如 ref()）
+        return false
+      }
+      
+      // 属性访问通常可以推导类型（如 ref.value）
+      if (node.type === 'MemberExpression') {
+        return true
+      }
+      
+      // await 表达式可以推导类型（等待 Promise 的结果）
+      if (node.type === 'AwaitExpression') {
+        return true
+      }
+      
+      // 其他情况默认无法推导类型
+      return false
+    }
+
+    /**
+     * 检查变量声明中的隐式 any 类型
+     */
+    function checkVariableDeclaration(node) {
+      // 遍历所有声明
+      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) {
+                    anyUsages.push({
+                      node: declaration,
+                      type: 'implicit',
+                    })
+                  }
+                }
+              }
+            }
+          } else if (declaration.id.typeAnnotation) {
+            // 检查类型注解中的 any
+            checkTypeAnnotation(declaration.id)
+          }
+        }
+      })
+    }
+
+    /**
+     * 检查类型别名和接口中的 any 类型
+     */
+    function checkTypeDeclaration(node) {
+      if (node.typeAnnotation) {
+        checkTypeNodeForAny(node.typeAnnotation, node)
+      }
+    }
+
+    /**
+     * 在文件结束时检查 any 类型使用次数
+     */
+    function checkAnyUsageCount() {
+      if (anyUsages.length > maxAnyCount) {
+        // 报告第一个超出限制的 any 使用（第 maxAnyCount + 1 个）
+        const firstExceededUsage = anyUsages[maxAnyCount]
+        context.report({
+          node: firstExceededUsage.node,
+          messageId: 'exceedMaxAnyCount',
+          data: {
+            maxAnyCount,
+            currentCount: anyUsages.length,
+          },
+        })
+      }
+    }
+
+    return {
+      TSAnyKeyword: checkTSAnyKeyword,
+      VariableDeclaration: checkVariableDeclaration,
+      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",
   "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'