@foundbyte/eslint-plugin 1.1.1 → 1.1.4-alpha

package/README.md

@@ -24,7 +24,9 @@ module.exports = {
     // 启用所有推荐的规则
     '@foundbyte/arrow-function-padding': 'error',
     '@foundbyte/no-initial-as-assertion': ['error', {
-      'excludeMethodReturns': ['map', 'parse', 'filter', 'reduce','querySelector']
+      excludeVariableAssertions: true,
+      excludeTypePatterns: ['^const$', '^[A-Z]$'],
+      excludeMethodReturns: ['parse', 'querySelector']
     }],
     '@foundbyte/hooks-arrow-function-only': 'error',
     '@foundbyte/type-comment-requirement': ['error', {
@@ -45,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` 类型断言，强制使用显式类型注解。
@@ -106,6 +201,11 @@ const parsed = JSON.parse(jsonString) as { name: string } // 不会报错
   - 支持全局函数：`JSON.parse` 等
   - 支持链式调用：`arr.map().filter() as Type`
 
+- `excludeTypePatterns` (array, 默认 []): 排除匹配正则表达式模式的类型断言
+  - 支持正则表达式字符串数组
+  - 用于排除特定的类型断言模式，如 `as const`
+  - 示例：`['^const$', '^Readonly<.*>$']` 可以排除 `as const` 和 `as Readonly<...>`
+
 **注意：**
 - 该规则检查变量声明时的所有类型断言，包括嵌套在函数调用参数中的类型断言
 - 推荐使用显式类型注解，因为类型断言会绕过 TypeScript 的类型检查

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/lib/rules/no-initial-as-assertion.d.ts

@@ -12,6 +12,12 @@ export interface NoInitialAsAssertionOptions {
      * @default []
      */
   excludeMethodReturns?: string[]
+
+  /**
+     * 排除匹配正则表达式模式的类型断言
+     * @default []
+     */
+  excludeTypePatterns?: string[]
 }
 
 /**

package/lib/rules/no-initial-as-assertion.js

@@ -23,6 +23,14 @@ module.exports = {
                         },
                         default: [],
                         description: '排除特定方法返回类型的 as 断言'
+                    },
+                    excludeTypePatterns: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        default: [],
+                        description: '排除匹配正则表达式模式的类型断言'
                     }
                 },
                 additionalProperties: false
@@ -37,6 +45,7 @@ module.exports = {
         const options = context.options[0] || {};
         const excludeVariableAssertions = options.excludeVariableAssertions || false;
         const excludeMethodReturns = options.excludeMethodReturns || [];
+        const excludeTypePatterns = options.excludeTypePatterns || [];
 
         /**
          * 检查是否是变量断言的情况
@@ -45,9 +54,10 @@ module.exports = {
          */
         function isVariableAssertion(node) {
             // 检查是否是变量断言：const a = variable as Type
+            // 当 excludeVariableAssertions 为 true 时，返回 true 表示要排除
             return node.expression && 
                    node.expression.type === 'Identifier' && 
-                   !excludeVariableAssertions;
+                   excludeVariableAssertions;
         }
 
         /**
@@ -78,6 +88,45 @@ module.exports = {
             return false;
         }
 
+        /**
+         * 检查是否是 as const 断言
+         * @param {Object} node TSAsExpression 节点
+         * @returns {boolean}
+         */
+        function isConstAssertion(node) {
+            // 检查是否是 as const 断言
+            return node.typeAnnotation && 
+                   node.typeAnnotation.type === 'TSTypeReference' &&
+                   node.typeAnnotation.typeName &&
+                   node.typeAnnotation.typeName.name === 'const';
+        }
+
+        /**
+         * 检查是否匹配排除的类型模式
+         * @param {Object} node TSAsExpression 节点
+         * @returns {boolean}
+         */
+        function matchesExcludedTypePattern(node) {
+            if (excludeTypePatterns.length === 0) {
+                return false;
+            }
+
+            // 获取类型注解的源代码
+            const sourceCode = context.getSourceCode();
+            const typeAnnotationText = sourceCode.getText(node.typeAnnotation);
+
+            // 检查是否匹配任何排除模式
+            return excludeTypePatterns.some(pattern => {
+                try {
+                    const regex = new RegExp(pattern);
+                    return regex.test(typeAnnotationText);
+                } catch (error) {
+                    // 如果正则表达式无效，忽略该模式
+                    return false;
+                }
+            });
+        }
+
         /**
          * 检查变量声明是否使用了 as 类型断言
          * @param {Object} node AST节点
@@ -104,6 +153,11 @@ module.exports = {
                             return;
                         }
 
+                        // 排除匹配正则表达式模式的类型断言
+                        if (matchesExcludedTypePattern(declaration.init)) {
+                            return;
+                        }
+
                         // 对于直接的类型断言，应该限制
                         // 例如：const a = 1 as number, const a = {} as { s: string }
                         context.report({

package/package.json

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