mm_eslint 1.2.3 → 1.2.5

package/index.js

@@ -790,7 +790,7 @@ Detector.prototype._checkPropName = function (name, val_node, parent_node) {
   const val_type = this._getPropType(val_node, name, parent_node);
 
   if (use_strong_val) {
-    this._checkPropStrong(name, val_type, config, errors);
+    this._checkPropStrong(name, val_type, config, errors, val_node);
   } else {
     this._checkPropWeak(name, val_type, config, errors);
   }
@@ -820,6 +820,11 @@ Detector.prototype._checkPropLength = function (name, config, errors) {
 
 /**
  * 强验证模式检查
+ * @param {string} name - 属性名
+ * @param {string} val_type - 值类型
+ * @param {Object} config - 配置对象
+ * @param {Array} errors - 错误数组
+ * @param {Object} val_node - 属性值AST节点（可选）
  * @private
  */
 Detector.prototype._checkPropStrong = function (
@@ -827,6 +832,7 @@ Detector.prototype._checkPropStrong = function (
   val_type,
   config,
   errors,
+  val_node,
 ) {
   switch (val_type) {
     case "function":
@@ -836,7 +842,7 @@ Detector.prototype._checkPropStrong = function (
       this._checkMethodProp(name, config, errors);
       break;
     case "class":
-      this._checkClassProp(name, config, errors);
+      this._checkClassProp(name, config, errors, val_node);
       break;
     case "constant":
       this._checkConstProp(name, config, errors);
@@ -884,12 +890,17 @@ Detector.prototype._checkFuncProp = function (name, config, errors) {
 
 /**
  * 检查类属性
+ * @param {string} name - 属性名
+ * @param {Object} config - 配置对象
+ * @param {Array} errors - 错误数组
+ * @param {Object} val_node - 属性值AST节点（可选）
  * @private
  */
-Detector.prototype._checkClassProp = function (name, config, errors) {
-  // 对于类实例的属性名，允许使用小驼峰命名
-  // 只有类定义本身才要求使用PascalCase
-  const is_class_instance = true; // 这里可以根据上下文进一步优化
+Detector.prototype._checkClassProp = function (name, config, errors, val_node) {
+  // 根据值节点类型判断是类定义还是类实例
+  const is_class_definition = val_node && val_node.type === "CallExpression" && 
+                             val_node.callee && val_node.callee.name === "require";
+  const is_class_instance = !is_class_definition;
   
   if (is_class_instance) {
     // 类实例允许使用小驼峰命名
@@ -1782,27 +1793,39 @@ Detector.prototype._checkRecommen = function (name, rule_type, config, recommend
 
       if (should_recommend) {
         // 生成推荐建议：将目标词替换为推荐类别词
-        const suggestions = category_words.map((word) => {
-          // 智能替换：保持原始大小写格式
-          const regex = new RegExp(word, 'gi');
-          return name.replace(regex, (match) => {
-            // 保持原始大小写格式
-            if (match === match.toUpperCase()) {
-              return category.toUpperCase();
-            } else if (match[0] === match[0].toUpperCase()) {
-              return category[0].toUpperCase() + category.slice(1);
-            } else {
-              return category;
+        const suggestions = [];
+        
+        // 为每个检测到的目标词生成一个推荐
+        words.forEach((word) => {
+          if (category_words.includes(word)) {
+            // 只生成使用类别词替换的推荐，不包含原始词
+            const regex = new RegExp(word, 'gi');
+            const suggestion = name.replace(regex, (match) => {
+              // 保持原始大小写格式
+              if (match === match.toUpperCase()) {
+                return category.toUpperCase();
+              } else if (match[0] === match[0].toUpperCase()) {
+                return category[0].toUpperCase() + category.slice(1);
+              } else {
+                return category;
+              }
+            });
+            
+            // 只有当推荐结果与原始名称不同时才添加
+            if (suggestion !== name) {
+              suggestions.push(suggestion);
             }
-          });
+          }
         });
 
-        recommendations.push({
-          original: name,
-          category: category,
-          suggestions: suggestions,
-          message: `检测到"${category_words.join('、')}"，推荐使用: ${suggestions.join(', ')}`
-        });
+        if (suggestions.length > 0) {
+          recommendations.push({
+            original: name,
+            category: category,
+            suggestions: suggestions,
+            message: `检测到"${category_words.join('、')}"，推荐使用: ${suggestions.join(', ')}`
+          });
+        }
       }
     }
   });
@@ -2189,10 +2212,10 @@ const variable_name_rule = {
             node.init.callee &&
             node.init.callee.type === "Identifier" &&
             /^[A-Z][a-zA-Z]*$/.test(node.init.callee.name)) {
-            // 这是类实例，应该由变量名规则处理（类实例是变量，不是类）
+            // 这是类实例，应该使用函数名规则（camelCase）
             const class_instance_name = node.id.name;
-            const detector = new Detector({ "variable-name": options });
-            const result = detector.checkName(class_instance_name, "variable-name");
+            const detector = new Detector({ "function-name": options });
+            const result = detector.checkName(class_instance_name, "function-name");
 
             if (!result.valid) {
               result.errors.forEach((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_eslint",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "ESLint plugin for naming conventions - PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules",
   "main": "index.js",
   "keywords": [