@foundbyte/eslint-plugin 1.0.9 → 1.1.0

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

@@ -14,44 +14,6 @@ module.exports = {
     },
 
     create(context) {
-        /**
-         * 递归检查 AST 节点中是否包含类型断言
-         * @param {Object} node AST节点
-         * @param {Set} visited 已访问的节点集合，用于避免循环引用
-         * @returns {boolean} 是否包含类型断言
-         */
-        function containsTypeAssertion(node, visited = new Set()) {
-            if (!node || typeof node !== 'object') return false;
-            
-            // 避免循环引用
-            if (visited.has(node)) return false;
-            visited.add(node);
-            
-            // 如果当前节点是类型断言，返回 true
-            if (node.type === 'TSAsExpression') {
-                return true;
-            }
-            
-            // 递归检查子节点，只检查 AST 相关的属性
-            const astKeys = ['init', 'expression', 'body', 'declarations', 'arguments', 'callee', 'left', 'right'];
-            
-            for (const key of astKeys) {
-                if (node[key]) {
-                    if (Array.isArray(node[key])) {
-                        for (const child of node[key]) {
-                            if (containsTypeAssertion(child, visited)) {
-                                return true;
-                            }
-                        }
-                    } else if (containsTypeAssertion(node[key], visited)) {
-                        return true;
-                    }
-                }
-            }
-            
-            return false;
-        }
-
         /**
          * 检查变量声明是否使用了 as 类型断言
          * @param {Object} node AST节点
@@ -66,13 +28,32 @@ module.exports = {
             node.declarations.forEach(declaration => {
                 // 检查是否有初始化表达式
                 if (declaration.init) {
-                    // 检查初始化表达式是否包含类型断言
-                    if (containsTypeAssertion(declaration.init)) {
+                    // 检查初始化表达式是否直接是类型断言
+                    if (declaration.init.type === 'TSAsExpression') {
+                        // 对于直接的类型断言，应该限制
+                        // 例如：const a = 1 as number, const a = {} as { s: string }
                         context.report({
-                            node: declaration,
+                            node: declaration.init,
                             messageId: 'noInitialAsAssertion',
                         });
                     }
+                    // 检查函数调用的参数中是否包含类型断言
+                    else if (declaration.init.type === 'CallExpression') {
+                        // 检查函数调用的参数
+                        if (declaration.init.arguments && declaration.init.arguments.length > 0) {
+                            for (const arg of declaration.init.arguments) {
+                                if (arg.type === 'TSAsExpression') {
+                                    // 对于函数参数中的类型断言，应该限制
+                                    // 例如：ref({} as string) 中的 {} as string
+                                    context.report({
+                                        node: arg,
+                                        messageId: 'noInitialAsAssertion',
+                                    });
+                                    break; // 只报告第一个找到的类型断言
+                                }
+                            }
+                        }
+                    }
                 }
             });
         }

package/package.json

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