eslint-plugin-better-codes 1.0.1 → 1.0.4

package/README.md

@@ -51,6 +51,16 @@ module.exports = {
 ### function-with-try-catch
 
 强制函数必须包含 try-catch 语句块
+- 普通函数
+- 箭头函数
+- 方法函数
+
+不校验的情况：
+- React组件函数
+- 函数体只有一行代码的函数
+- 用于map/forEach中返回元素/组件用于渲染的箭头函数
+
+<!-- TODO:待解决的问题：针对返回结果为true/false的函数，使用try...catch进入catch分支之后改返回false还是true还是不返回(undefined)，因为按照之前的逻辑报错之后后续的代码不应再执行的，但是现在会直接继续走false/true的逻辑，造成逻辑错误 -->
 
 ## 许可证
 

package/libs/function-with-try-catch-code.js

@@ -3,89 +3,271 @@
  * 对于有函数体且包含语句的函数，如果没有 try/catch 报警
  */
 function containsTryStatement(node) {
-	let found = false;
-	const seen = new Set();
-	function traverse(n) {
-		if (!n || found) return;
-		if (seen.has(n)) return;
-		if (Array.isArray(n)) {
-			for (const item of n) {
-				traverse(item);
-				if (found) return;
-			}
-			return;
-		}
-		if (typeof n !== "object") return;
-		seen.add(n);
-		if (n.type === "TryStatement") {
-			found = true;
-			return;
-		}
-		for (const key of Object.keys(n)) {
-			if (found) break;
-			const child = n[key];
-			if (child && typeof child === "object") {
-				traverse(child);
-			}
-		}
-	}
-	traverse(node);
-	return found;
+  let found = false;
+  const seen = new Set();
+  function traverse(n) {
+    try {
+      if (!n || found) return;
+      if (seen.has(n)) return;
+      if (Array.isArray(n)) {
+        for (const item of n) {
+          traverse(item);
+          if (found) return;
+        }
+        return;
+      }
+      if (typeof n !== "object") return;
+      seen.add(n);
+      if (n.type === "TryStatement") {
+        found = true;
+        return;
+      }
+      for (const key of Object.keys(n)) {
+        if (found) break;
+        // 避免遍历父指针和非 AST 节点的额外属性，防止从一个函数遍历到其他函数
+        if (
+          key === "parent" ||
+          key === "loc" ||
+          key === "range" ||
+          key === "leadingComments" ||
+          key === "trailingComments" ||
+          key === "comments" ||
+          key === "tokens"
+        ) {
+          continue;
+        }
+        const child = n[key];
+        if (child && typeof child === "object") {
+          traverse(child);
+        }
+      }
+    } catch (err) {
+      console.error(err);
+    }
+  }
+  traverse(node);
+  return found;
 }
 
 // 判断是否为React组件函数
 function isReactComponentFunction(node) {
-	return node.type === "FunctionDeclaration" && node.id && node.id.name === "render";
+  try {
+    let name;
+
+    // 尝试从节点自身或父节点取名（支持 const X = () => {}）
+    if (
+      node.type === "FunctionDeclaration" ||
+      node.type === "FunctionExpression" ||
+      node.type === "ArrowFunctionExpression"
+    ) {
+      if (node.id && node.id.name) name = node.id.name;
+      else if (
+        node.parent &&
+        node.parent.type === "VariableDeclarator" &&
+        node.parent.id &&
+        node.parent.id.name
+      ) {
+        name = node.parent.id.name;
+      } else if (
+        node.parent &&
+        node.parent.type === "Property" &&
+        node.parent.key
+      ) {
+        name =
+          node.parent.key.name ||
+          (node.parent.key.value && String(node.parent.key.value));
+      }
+    } else if (node.type === "MethodDefinition" || node.type === "Property") {
+      name =
+        node.key &&
+        (node.key.name || (node.key.value && String(node.key.value)));
+    }
+    // 名字首字母大写视为组件
+    if (name && /^[A-Z]/.test(name)) return true;
+
+    // 检查是否包含或返回 JSX
+    function containsJSX(n, seen = new Set()) {
+      try {
+        if (!n || seen.has(n)) return false;
+        seen.add(n);
+        if (Array.isArray(n)) {
+          for (const it of n) if (containsJSX(it, seen)) return true;
+          return false;
+        }
+        if (typeof n !== "object") return false;
+        if (n.type === "JSXElement" || n.type === "JSXFragment") return true;
+        // 对于返回语句，直接检查返回的表达式
+        if (n.type === "ReturnStatement" && n.argument)
+          return containsJSX(n.argument, seen);
+        for (const k of Object.keys(n)) {
+          if (k === "parent" || k === "loc" || k === "range") continue;
+          if (containsJSX(n[k], seen)) return true;
+        }
+        return false;
+      } catch (err) {
+        return false;
+      }
+    }
+
+    if (node.body && containsJSX(node.body)) return true;
+
+    // 检查是否被 React.memo/forwardRef 等包裹：父是 CallExpression，callee 为 Identifier 或 MemberExpression 包含 memo/forwardRef
+    let p = node.parent;
+    if (p && p.type === "CallExpression") {
+      const callee = p.callee;
+      if (callee) {
+        if (
+          callee.type === "Identifier" &&
+          /memo|forwardRef/i.test(callee.name)
+        )
+          return true;
+        if (
+          callee.type === "MemberExpression" &&
+          callee.property &&
+          /memo|forwardRef/i.test(callee.property.name)
+        )
+          return true;
+      }
+    }
+
+    return false;
+  } catch (err) {
+    return false;
+  }
 }
 
-module.exports = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description: "提醒函数内部应包含 try...catch 以便处理异常",
-			category: "Best Practices",
-			recommended: false,
-		},
-		schema: [],
-	},
-	create(context) {
-		function reportIfMissingTry(node, name) {
-			// 箭头函数表达式且为表达式体，跳过
-			if (node.type === "ArrowFunctionExpression" && node.body && node.body.type !== "BlockStatement") {
-				return;
-			}
-			const body = node.body;
-			if (!body || body.type !== "BlockStatement") return;
-			const stmts = body.body || [];
-			// 如果函数体为空或只有注释/空，则跳过
-			if (stmts.length === 0) return;
-			// 如果函数体中包含 TryStatement，说明已处理，跳过
-			if (containsTryStatement(body)) return;
-			context.report({
-				node,
-				message: `${name || '函数'} 未包含 try...catch，建议添加错误处理`,
-			});
-		}
+// 判断函数体是否只有一行
+function isOnlyOneLine(body) {
+  try {
+    if (!body || body.type !== "BlockStatement") return false;
+    const stmts = body.body || [];
+    return stmts.length === 1 && stmts[0].type === "ExpressionStatement";
+  } catch (err) {
+    return false;
+  }
+}
 
-		return {
-			FunctionDeclaration(node) {
-				const name = node.id && node.id.name;
-				reportIfMissingTry(node, name);
-			},
-			FunctionExpression(node) {
-				const name = node.id && node.id.name;
-				reportIfMissingTry(node, name);
-			},
-			ArrowFunctionExpression(node) {
-				reportIfMissingTry(node, '箭头函数');
-			},
-			MethodDefinition(node) {
-				// 跳过 constructor/get/set
-				if (node.kind === 'constructor' || node.kind === 'get' || node.kind === 'set' || isReactComponentFunction(node)) return;
-				const key = node.key && (node.key.name || (node.key.value && String(node.key.value)));
-				if (node.value) reportIfMissingTry(node.value, key || '方法');
-			},
-		};
-	},
-};
+// 判断函数是否作为 array methods 的回调（如 map/forEach）直接返回用于渲染的元素/组件
+function isArrayMethodCallback(node) {
+  try {
+    if (!node || !node.parent) return false;
+    // 父节点应为 CallExpression，且当前函数是该调用的一个参数
+    const p = node.parent;
+    if (p.type !== "CallExpression") return false;
+    const args = p.arguments || [];
+    if (!args.includes(node)) return false;
+    const callee = p.callee;
+    if (!callee) return false;
+    // 支持形如 data.map(...) 或 data?.map(...)
+    if (callee.type === "MemberExpression") {
+      const prop = callee.property;
+      const name = prop && (prop.name || (prop.value && String(prop.value)));
+      // 判断返回语句
+      const returnNode = node.body?.body?.at(-1);
+      if (
+        name &&
+        /^(map|forEach)$/i.test(name) &&
+        returnNode &&
+        returnNode.type === "ReturnStatement" &&
+        JSON.stringify(returnNode.argument?.raw || "").startsWith("<") &&
+        JSON.stringify(returnNode.argument?.raw || "").endsWith(">")
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  } catch (err) {
+    console.log(err);
+  }
+}
 
+module.exports =  {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "提醒函数内部应包含 try...catch 以便处理异常",
+      category: "Best Practices",
+      recommended: false,
+    },
+    schema: [],
+  },
+  create(context) {
+    function reportIfMissingTry(node) {
+      try {
+        // 箭头函数表达式且为表达式体，跳过
+        if (
+          (node.type === "ArrowFunctionExpression" &&
+            node.body &&
+            node.body.type !== "BlockStatement") ||
+          // 作为 React 组件/组件函数跳过
+          isReactComponentFunction(node) ||
+          // 只有一行表达式的函数跳过
+          isOnlyOneLine(node.body) ||
+          // 作为 array 方法回调（如 map/forEach）用于渲染时跳过
+          isArrayMethodCallback(node)
+        ) {
+          return;
+        }
+        const body = node.body;
+        if (!body || body.type !== "BlockStatement") return;
+        const stmts = body.body || [];
+        // 如果函数体为空或只有注释/空，则跳过
+        if (stmts.length === 0) return;
+        // 如果函数体中包含 TryStatement，说明已处理，跳过
+        if (containsTryStatement(body)) return;
+        context.report({
+          node,
+          message: `函数未包含 try...catch，建议添加错误处理`,
+        });
+      } catch (err) {
+        console.error(err);
+      }
+    }
+
+    return {
+      FunctionDeclaration(node) {
+        try {
+          const name = node.id && node.id.name;
+          reportIfMissingTry(node, name);
+        } catch (err) {
+          console.error(err);
+        }
+      },
+      FunctionExpression(node) {
+        try {
+          const name = node.id && node.id.name;
+          reportIfMissingTry(node, name);
+        } catch (err) {
+          console.error(err);
+        }
+      },
+      ArrowFunctionExpression(node) {
+        try {
+          const name = node.id && node.id.name;
+          reportIfMissingTry(node, name);
+        } catch (err) {
+          console.error(err);
+        }
+      },
+      MethodDefinition(node) {
+        try {
+          // 跳过 constructor/get/set
+          if (
+            node.kind === "constructor" ||
+            node.kind === "get" ||
+            node.kind === "set" ||
+            isReactComponentFunction(node)
+          )
+            return;
+          const key =
+            node.key &&
+            (node.key.name || (node.key.value && String(node.key.value)));
+          if (node.value) reportIfMissingTry(node.value, key || "方法");
+        } catch (err) {
+          console.error(err);
+        }
+      },
+    };
+  },
+};

package/libs/no-commented-code.js

@@ -42,15 +42,19 @@ function isFunctionComment(comment, isBlock = false) {
  * @returns {Boolean} 是否为函数的功能注释
  */
 function isFuncComment(comment) {
-  if (
-    comment.includes("@param") ||
-    comment.includes("@returns") ||
-    comment.includes("@Description") ||
-    comment.includes("@description") ||
-    comment.includes("@comment") ||
-    comment.includes("@Comment")
-  ) {
-    return true;
+  try {
+    if (
+      comment.includes("@param") ||
+      comment.includes("@returns") ||
+      comment.includes("@Description") ||
+      comment.includes("@description") ||
+      comment.includes("@comment") ||
+      comment.includes("@Comment")
+    ) {
+      return true;
+    }
+  } catch (err) {
+    console.error(err);
   }
 }
 
@@ -77,90 +81,94 @@ module.exports = {
     ],
   },
   create(context) {
-    const sourceCode = context.getSourceCode();
-    const options = context.options[0] || {};
-    const minLines = options.minLines || 5;
-    let ignoredCount = 0; // 忽略次数
-    let singleLineCount = 0; // 单行注释行数 只计算最终实际校验生效的
-    return {
-      Program() {
-        const comments = sourceCode.getAllComments();
-        comments.forEach(comment => {
-          if (comment.loc) {
-            // 单行注释
-            if (comment.type === "Line") {
-              if (isFunctionComment(comment.value)) {
-                return;
-              }
-              singleLineCount++;
+    try {
+      const sourceCode = context.getSourceCode();
+      const options = context.options[0] || {};
+      const minLines = options.minLines || 5;
+      let ignoredCount = 0; // 忽略次数
+      let singleLineCount = 0; // 单行注释行数 只计算最终实际校验生效的
+      return {
+        Program() {
+          const comments = sourceCode.getAllComments();
+          comments.forEach(comment => {
+            if (comment.loc) {
+              // 单行注释
+              if (comment.type === "Line") {
+                if (isFunctionComment(comment.value)) {
+                  return;
+                }
+                singleLineCount++;
 
-              const lines = comment.value.split("\n");
-              // 过滤空行，只计算有实际内容的行
-              const codeLines = lines.filter(line => {
-                const trimmed = line.trim();
-                return trimmed.length > 0;
-              });
-              const isIgnored = codeLines[0].endsWith("ignore-eslint"); // 因默认添加了ignore-eslint，进行忽略校验
-              if (isIgnored && ignoredCount < minLines) {
-                ignoredCount++;
-                singleLineCount--;
-              }
-              // 优先检查忽略次数：当忽略累计次数达到阈值时，优先提示并禁止继续忽略
-              if (ignoredCount >= minLines) {
-                context.report({
-                  node: comment,
-                  message: `总忽略次数大于等于${minLines}次，请删除或保留为有效代码`,
-                  data: {
-                    lines: ignoredCount,
-                  },
-                });
-                return;
-              }
-              // 其次检查单行注释总数
-              if (singleLineCount >= minLines) {
-                context.report({
-                  node: comment,
-                  message: `单行注释大于等于 ${minLines} 行代码，请删除或保留为有效代码`,
-                  data: {
-                    lines: singleLineCount,
-                  },
-                });
-                return;
-              }
-              // 如果注释块包含多行代码逻辑
-              if (codeLines.length >= minLines) {
-                context.report({
-                  node: comment,
-                  message: `注释掉了 ${codeLines.length} 行代码，请删除或保留为有效代码`,
-                  data: {
-                    lines: codeLines.length,
-                  },
+                const lines = comment.value.split("\n");
+                // 过滤空行，只计算有实际内容的行
+                const codeLines = lines.filter(line => {
+                  const trimmed = line.trim();
+                  return trimmed.length > 0;
                 });
+                const isIgnored = codeLines[0].endsWith("ignore-eslint"); // 因默认添加了ignore-eslint，进行忽略校验
+                if (isIgnored && ignoredCount < minLines) {
+                  ignoredCount++;
+                  singleLineCount--;
+                }
+                // 优先检查忽略次数：当忽略累计次数达到阈值时，优先提示并禁止继续忽略
+                if (ignoredCount >= minLines) {
+                  context.report({
+                    node: comment,
+                    message: `总忽略次数大于等于${minLines}次，请删除或保留为有效代码`,
+                    data: {
+                      lines: ignoredCount,
+                    },
+                  });
+                  return;
+                }
+                // 其次检查单行注释总数
+                if (singleLineCount >= minLines) {
+                  context.report({
+                    node: comment,
+                    message: `单行注释大于等于 ${minLines} 行代码，请删除或保留为有效代码`,
+                    data: {
+                      lines: singleLineCount,
+                    },
+                  });
+                  return;
+                }
+                // 如果注释块包含多行代码逻辑
+                if (codeLines.length >= minLines) {
+                  context.report({
+                    node: comment,
+                    message: `注释掉了 ${codeLines.length} 行代码，请删除或保留为有效代码`,
+                    data: {
+                      lines: codeLines.length,
+                    },
+                  });
+                }
               }
-            }
-            // 多行注释
-            if (comment.type === "Block") {
-              if (isFunctionComment(comment.value, true)) {
-                return;
-              }
-              const lines = comment.value.split("\n");
-              const codeLines = lines.filter(line => {
-                const trimmed = line.trim();
-                return trimmed !== "*" && trimmed.length > 0 && trimmed; // 过滤掉空行和只包含*的行
-              });
-              if (codeLines.length >= minLines) {
-                context.report({
-                  node: comment,
-                  message: `注释掉了 ${codeLines.length} 行代码，请删除或保留为有效代码`,
-                  data: {
-                    lines: codeLines.length,
-                  },
+              // 多行注释
+              if (comment.type === "Block") {
+                if (isFunctionComment(comment.value, true)) {
+                  return;
+                }
+                const lines = comment.value.split("\n");
+                const codeLines = lines.filter(line => {
+                  const trimmed = line.trim();
+                  return trimmed !== "*" && trimmed.length > 0 && trimmed; // 过滤掉空行和只包含*的行
                 });
+                if (codeLines.length >= minLines) {
+                  context.report({
+                    node: comment,
+                    message: `注释掉了 ${codeLines.length} 行代码，请删除或保留为有效代码`,
+                    data: {
+                      lines: codeLines.length,
+                    },
+                  });
+                }
               }
             }
-          }
-        });
-      },
-    };
+          });
+        },
+      };
+    } catch (err) {
+      console.error(err);
+    }
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-better-codes",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "main": "index.js",
   "scripts": {
     "test": "npx eslint ./test.js"