mm_eslint 1.5.0 → 1.5.1

package/lib/detector/const_name.js

@@ -200,6 +200,11 @@ ConstName.prototype._isConstantValue = function (value_node) {
     return false; // 其他函数调用不是常量
   }
 
+  // 排除await表达式
+  if (value_node.type === 'AwaitExpression') {
+    return false; // await表达式的结果通常是可变的，不是常量
+  }
+
   // 默认情况下，如果不是排除的类型，就认为是常量
   return true;
 }
@@ -500,10 +505,28 @@ ConstName.prototype.ExportNamedDeclaration = function (node) {
     for (let i = 0; i < node.declaration.declarations.length; i++) {
       let declaration = node.declaration.declarations[i];
       if (declaration.id && declaration.id.type === 'Identifier') {
-        let name = declaration.id.name;
-        let error = this.check(node, name, 'export-constant');
-        this.report(node, error, 'export-constant');
-        return error;
+        // 排除函数：如果右边是函数表达式或箭头函数，则不是常量
+        if (declaration.init && (declaration.init.type === 'FunctionExpression' || declaration.init.type === 'ArrowFunctionExpression')) {
+          return;
+        }
+        
+        // 排除类：如果右边是类表达式，则不是常量
+        if (declaration.init && declaration.init.type === 'ClassExpression') {
+          return;
+        }
+        
+        // 排除类实例：如果右边是 new 表达式，则不是常量
+        if (declaration.init && declaration.init.type === 'NewExpression') {
+          return;
+        }
+        
+        // 判断是否为常量（包括 Object.freeze() 等情况）
+        if (this._isConstantValue(declaration.init)) {
+          let name = declaration.id.name;
+          let error = this.check(node, name, 'export-constant');
+          this.report(node, error, 'export-constant');
+          return error;
+        }
       }
     }
   }

package/lib/detector/variable_name.js

@@ -79,33 +79,48 @@ VariableName.prototype.VariableDeclaration = function (node) {
         // 检测变量名
         let name = decl.id.name;
         
-        // 对于const声明，只处理右边是CallExpression的情况
-        if (decl.init && decl.init.type === 'CallExpression') {
-          // 排除require()调用，因为导入的模块类型无法确定
-          if (decl.init.callee && decl.init.callee.type === 'Identifier' && decl.init.callee.name === 'require') {
-            return; // 跳过require()调用
-          }
-          
-          // 排除Object.freeze()等常量函数调用
-          if (decl.init.callee && decl.init.callee.type === 'MemberExpression' &&
-            decl.init.callee.object && decl.init.callee.object.type === 'Identifier' &&
-            decl.init.callee.object.name === 'Object' && decl.init.callee.property &&
-            decl.init.callee.property.type === 'Identifier' && (
-              decl.init.callee.property.name === 'freeze' ||
-              decl.init.callee.property.name === 'seal' ||
-              decl.init.callee.property.name === 'preventExtensions'
-            )) {
-            return; // 跳过常量函数调用
+        // 对于const声明，处理右边是CallExpression或AwaitExpression的情况
+        if (decl.init) {
+          // 对于AwaitExpression，直接处理
+          if (decl.init.type === 'AwaitExpression') {
+            let error = {
+              message: `变量'${name}'应该使用let标签声明而不是const标签声明`,
+              fix: function(fixer) {
+                return fixer.replaceTextRange([node.range[0], node.range[0] + 5], 'let');
+              }
+            };
+            this.report(node, error, 'variable');
+            return error;
           }
           
-          let error = {
-            message: `变量'${name}'应该使用let标签声明而不是const标签声明`,
-            fix: function(fixer) {
-              return fixer.replaceTextRange([node.range[0], node.range[0] + 5], 'let');
+          // 对于CallExpression，进行详细排除检查
+          else if (decl.init.type === 'CallExpression') {
+            // 排除require()调用，因为导入的模块类型无法确定
+            if (decl.init.callee && decl.init.callee.type === 'Identifier' && decl.init.callee.name === 'require') {
+              return; // 跳过require()调用
             }
-          };
-          this.report(node, error, 'variable');
-          return error;
+            
+            // 排除Object.freeze()等常量函数调用
+            if (decl.init.callee && decl.init.callee.type === 'MemberExpression' &&
+              decl.init.callee.object && decl.init.callee.object.type === 'Identifier' &&
+              decl.init.callee.object.name === 'Object' && decl.init.callee.property &&
+              decl.init.callee.property.type === 'Identifier' && (
+                decl.init.callee.property.name === 'freeze' ||
+                decl.init.callee.property.name === 'seal' ||
+                decl.init.callee.property.name === 'preventExtensions'
+              )) {
+              return; // 跳过常量函数调用
+            }
+            
+            let error = {
+              message: `变量'${name}'应该使用let标签声明而不是const标签声明`,
+              fix: function(fixer) {
+                return fixer.replaceTextRange([node.range[0], node.range[0] + 5], 'let');
+              }
+            };
+            this.report(node, error, 'variable');
+            return error;
+          }
         }
         // 对于const声明的其他情况，跳过变量规则检测（由常量规则处理）
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_eslint",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "ESLint plugin for personal naming conventions - supports PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules with intelligent recommendations",
   "main": "index.js",
   "keywords": [