@foundbyte/eslint-plugin 1.1.1 → 1.1.2

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$'],
+      excludeMethodReturns: ['parse', 'querySelector']
     }],
     '@foundbyte/hooks-arrow-function-only': 'error',
     '@foundbyte/type-comment-requirement': ['error', {
@@ -106,6 +108,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/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.2",
   "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",