mm_eslint 1.4.5 → 1.4.6

package/{config.js → lib/config.js}

@@ -15,6 +15,7 @@ class Config {
         'class-instance': [],
         'function': [],
         'param': [],
+        'object': [],
         'variable': [],
         'constant': []
       },
@@ -24,6 +25,7 @@ class Config {
         'class-instance': [],
         'function': [],
         'param': [],
+        'object': [],
         'variable': [],
         'constant': []
       },
@@ -33,6 +35,7 @@ class Config {
         'class-instance': {},
         'function': {},
         'param': {},
+        'object': {},
         'variable': {},
         'constant': {}
       }
@@ -65,7 +68,7 @@ Config.prototype.getRegex = function (style) {
  * @returns {Array} 禁止拼接词列表
  */
 Config.prototype.getForbiddenWords = function (name_type) {
-  let type = name_type.replace('property-', '').replace('instance-', '').replace('private-', '').replace('internal-', '').replace('prototype-', '');
+  let type = this.getType(name_type);
   var forbidden = {
     'class': [
       'manager',
@@ -301,43 +304,27 @@ Config.prototype.getBaseRule = function (name_type) {
       single_word: true,
       single_word_len: 8
     },
-    'param-function': {
-      name: '函数类型参数',
+    'object': {
+      name: '对象名',
       min: 1,
       max: 20,
-      styles: ['camelCase'],
-      single_word: true,
-      single_word_len: 8
-    },
-    'param-class': {
-      name: '类类型参数',
-      min: 1,
-      max: 20,
-      styles: ['PascalCase'],
-      single_word: true,
-      single_word_len: 8
-    },
-    'param-object': {
-      name: '对象类型参数',
-      min: 1,
-      max: 20,
-      styles: ['snake_case'],
+      styles: ['camelCase', 'snake_case'],
       single_word: true,
       single_word_len: 8
     },
-    'param-variable': {
-      name: '变量类型参数',
+    'variable': {
+      name: '变量名',
       min: 1,
       max: 20,
       styles: ['snake_case'],
       single_word: true,
       single_word_len: 8
     },
-    'variable': {
-      name: '变量名',
+    'property': {
+      name: '属性名',
       min: 1,
       max: 20,
-      styles: ['snake_case'],
+      styles: ['snake_case', 'camelCase', 'PascalCase'],
       single_word: true,
       single_word_len: 8
     },
@@ -374,7 +361,7 @@ Config.prototype.getRule = function (name_type) {
  * @returns {object} 推荐词映射
  */
 Config.prototype.getRecommendWords = function (name_type) {
-  let type = name_type.replace('property-', '').replace('instance-', '').replace('private-', '').replace('internal-', '').replace('prototype-', '');
+  let type = this.getType(name_type);
   var recommend = {
     'class': {
       'App': ['Application'],
@@ -487,17 +474,33 @@ Config.prototype.getRecommendWords = function (name_type) {
   return {};
 };
 
+Config.prototype.getType = function (name_type) {
+  let type = name_type.replace('property-', '').replace('internal-', '').replace('private-', '').replace('internal-', '').replace('prototype-', '').replace('use-', '').replace('super-', '').replace('static-', '').replace('param-', '').replace('export-', '');
+  return type;
+}
+
 /**
  * 获取忽略词列表
  * @param {string} name_type 名称类型
  * @returns {Array} 忽略词列表
  */
 Config.prototype.getIgnoreWords = function (name_type) {
-  let type = name_type.replace('property-', '').replace('instance-', '').replace('private-', '').replace('internal-', '').replace('prototype-', '');
+  let type = this.getType(name_type);
   var ignore = {
     'class': [
       'exports', 'Middleware', 'Component', 'Controller', 'Repository', 'Interface', 'Transformer', 'Template'
     ],
+    'class-instance': [
+      // JavaScript 内置全局对象（只保留不符合小驼峰规范的）
+      'JSON', 'Math', 'RegExp', 'EvalError', 'RangeError', 'ReferenceError', 
+      'SyntaxError', 'TypeError', 'URIError', 'WeakMap', 'WeakSet', 'Promise', 
+      'Proxy', 'Reflect', 'Intl', 'ArrayBuffer', 'DataView', 'Float32Array', 'Float64Array',
+      'Int8Array', 'Int16Array', 'Int32Array', 'Uint8Array', 'Uint16Array', 'Uint32Array',
+      'Uint8ClampedArray', 'BigInt64Array', 'BigUint64Array', 'Atomics', 'SharedArrayBuffer',
+      'URL', 'URLSearchParams', 'Headers', 'Request', 'Response', 'FormData', 'Blob', 'File',
+      'FileReader', 'Image', 'Audio', 'Video', 'Canvas', 'WebSocket', 'EventSource',
+      'XMLHttpRequest', 'Infinity', 'NaN', 'global'
+    ],
     'function': [
       'constructor', 'prototype', 'hasOwnProperty',
       'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString',
@@ -558,38 +561,62 @@ Config.prototype.getTypeNameMap = function () {
     var type_name_map = {
     'function': '函数',
     'variable': '变量',
-    'param': '参数',
+    'object': '对象',
     'class-instance': '类实例',
     'class': '类',
     'constant': '常量',
+    'super-class': '继承-类',
+    // 属性
+    'property': '属性',
     'property-function': '属性—函数',
     'property-variable': '属性—变量',
+    'property-object': '属性—对象',
     'property-class-instance': '属性—类实例',
     'property-class': '属性—类',
     'property-constant': '属性—常量',
+    // 静态属性
     'static-function': '静态属性—函数',
     'static-variable': '静态属性—变量',
+    'static-object': '静态属性—对象',
     'static-class-instance': '静态属性—类实例',
     'static-class': '静态属性—类',
     'static-constant': '静态属性—常量',
-    'prototype-function': '原型函数',
-    'prototype-variable': '原型变量',
-    'prototype-class-instance': '原型类实例',
+    // 原型属性
+    'prototype-class-instance': '原型属性—类实例',
+    'prototype-function': '原型属性—函数',
+    'prototype-variable': '原型属性—变量',
+    'prototype-object': '原型属性—对象',
+    // 私有属性
     'private-function': '私有属性—函数',
     'private-variable': '私有属性—变量',
+    'private-object': '私有属性—对象',
     'private-class-instance': '私有属性—类实例',
+    // 内部属性
     'internal-function': '内部属性—函数',
     'internal-variable': '内部属性—变量',
+    'internal-object': '内部属性—对象',
     'internal-class-instance': '内部属性—类实例',
+    // 引用
     'use-variable': '引用-变量',
     'use-function': '引用-函数',
+    'use-object': '引用-对象',
     'use-class': '引用-类',
     'use-constant': '引用-常量',
     'use-class-instance': '引用-类实例',
+    // 参数
+    'param': '参数',
     'param-class': '参数—类',
     'param-class-instance': '参数—类实例',
     'param-variable': '参数—变量',
-    'param-function': '参数—函数'
+    'param-object': '参数—对象',
+    'param-function': '参数—函数',
+    // 导出
+    'export-class': '导出-类',
+    'export-class-instance': '导出-类实例',
+    'export-variable': '导出-变量',
+    'export-object': '导出-对象',
+    'export-function': '导出-函数',
+    'export-constant': '导出-常量'
   };
   return type_name_map;
 }

package/lib/detector/class_instance_name.js

@@ -0,0 +1,246 @@
+const { Name } = require('./name.js');
+
+/**
+ * 类实例名检测器类
+ * 负责检测类实例名是否符合命名规范
+ */
+class ClassInstanceName extends Name {
+  constructor(context, config) {
+    super(context, config);
+  }
+}
+
+/**
+ * 变量声明节点检测函数
+ * @param {Object} node - 变量声明节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.VariableDeclaration = function (node) {
+  // 判断右边是否有 new 表达式
+  if (node.declarations[0].init && node.declarations[0].init.type === 'NewExpression') {
+    let name = node.declarations[0].id.name;
+    let original_type = 'class-instance';
+    let error = this.check(node.declarations[0].id, name, original_type);
+    this.report(node.declarations[0].id, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否有正则表达式字面量（RegExp实例）
+  if (node.declarations[0].init && node.declarations[0].init.type === 'Literal' &&
+    node.declarations[0].init.regex) {
+    let name = node.declarations[0].id.name;
+    let original_type = 'class-instance';
+    let error = this.check(node.declarations[0].id, name, original_type);
+    this.report(node.declarations[0].id, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否直接赋值类实例名
+  if (node.declarations[0].init && node.declarations[0].init.type === 'Identifier') {
+    // 根据右边值的类型决定左边变量的类型
+    let original_type = this._getOriginalType(node.declarations[0], 'VariableDeclaration');
+
+    // 如果右边是类实例，左边变量应该按照类实例的命名规范检测（小驼峰）
+    if (original_type === 'class-instance') {
+      let name = node.declarations[0].id.name;
+      let error = this.check(node.declarations[0].id, name, 'class-instance');
+      this.report(node.declarations[0].id, error, 'class-instance');
+      return error;
+    }
+  }
+}
+
+/**
+ * 属性节点检测函数
+ * @param {Object} node - 属性节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.Property = function (node) {
+  // 判断右边是否有 new 表达式
+  if (node.value.type === 'NewExpression') {
+    let name = node.key.name;
+    let original_type = 'property-class-instance';
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否直接定义为类实例名
+  if (node.value.type === 'Identifier') {
+    // 根据右边值的类型决定左边属性的类型
+    let original_type = this._getOriginalType(node, 'Property');
+
+    // 如果右边是类实例，左边属性应该按照类实例的命名规范检测（小驼峰）
+    if (original_type === 'class-instance') {
+      let name = node.key.name;
+      let error = this.check(node, name, 'property-class-instance');
+      this.report(node, error, 'property-class-instance');
+      return error;
+    }
+  }
+}
+
+/**
+ * 类属性定义节点检测函数
+ * @param {Object} node - 类属性定义节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.PropertyDefinition = function (node) {
+  // 判断右边是否有 new 表达式
+  if (node.value && node.value.type === 'NewExpression') {
+    let name = node.key.name;
+    let original_type = 'property-class-instance';
+    if (node.static) {
+      original_type = 'static-class-instance';
+    }
+    else if (node.key.type === 'PrivateIdentifier') {
+      original_type = 'private-class-instance';
+    }
+    else if (name.startsWith('_')) {
+      original_type = 'internal-class-instance';
+    }
+    let error = this.check(node, name, original_type);
+    this.report(node, error, original_type);
+    return error;
+  }
+
+  // 判断右边是否直接定义为类实例名
+  if (node.value && node.value.type === 'Identifier') {
+    // 根据右边值的类型决定左边属性的类型
+    let original_type = this._getOriginalType(node, 'PropertyDefinition');
+
+    // 如果右边是类实例，左边属性应该按照类实例的命名规范检测（小驼峰）
+    if (original_type === 'class-instance') {
+      let name = node.key.name;
+      let original_type = 'property-class-instance';
+      if (node.static) {
+        original_type = 'static-class-instance';
+      }
+      else if (node.key.type === 'PrivateIdentifier') {
+        original_type = 'private-class-instance';
+      }
+      else if (name.startsWith('_')) {
+        original_type = 'internal-class-instance';
+      }
+      let error = this.check(node, name, original_type);
+      this.report(node, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 赋值表达式节点检测函数
+ * @param {Object} node - 赋值表达式节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.AssignmentExpression = function (node) {
+  // 检测 exports 或 module.exports 赋值：exports.classInstance = classInstance;
+  // 排除右边是对象字面量的情况，交由Property检测器处理
+  if (node.operator === '=' && node.left && node.left.type === 'MemberExpression' &&
+    node.right && node.right.type !== 'ObjectExpression') {
+    // 检查左边是否为 exports 或 module.exports
+    let left_object = node.left.object;
+    let is_exports = false;
+
+    if (left_object.type === 'Identifier' && left_object.name === 'exports') {
+      is_exports = true;
+    } else if (left_object.type === 'MemberExpression' &&
+      left_object.object.type === 'Identifier' &&
+      left_object.object.name === 'module' &&
+      left_object.property.type === 'Identifier' &&
+      left_object.property.name === 'exports') {
+      is_exports = true;
+    }
+
+    if (is_exports && node.right && node.right.type === 'Identifier') {
+      // 先判断右边是否为类实例
+      let original_type = this._getOriginalType(node, 'AssignmentExpression');
+
+      // 如果右边是类实例，才检测左边的属性名
+      if (original_type === 'class-instance') {
+        let left_property = node.left.property;
+        if (left_property && left_property.type === 'Identifier') {
+          let name = left_property.name;
+          let error = this.check(left_property, name, 'property-class-instance');
+          this.report(left_property, error, 'property-class-instance');
+          return error;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 默认导出节点检测函数
+ * @param {Object} node - 默认导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.ExportDefaultDeclaration = function (node) {
+  // 检测导出的类实例名
+  if (node.declaration && node.declaration.type === 'Identifier') {
+    let name = node.declaration.name;
+    let type = this._getOriginalType(node.declaration, 'ExportDefaultDeclaration');
+    if (type === 'class-instance') {
+      let original_type = 'export-class-instance';
+      let error = this.check(node.declaration, name, original_type);
+      this.report(node.declaration, error, original_type);
+      return error;
+    }
+  }
+}
+
+/**
+ * 命名导出节点检测函数
+ * @param {Object} node - 命名导出节点
+ * @returns {Object|undefined} - 检测结果对象或undefined
+ */
+ClassInstanceName.prototype.ExportNamedDeclaration = function (node) {
+  // 检测导出的类实例声明（如 export const myInstance = new ClassName()）
+  if (node.declaration && node.declaration.type === 'VariableDeclaration') {
+    for (let i = 0; i < node.declaration.declarations.length; i++) {
+      let declaration = node.declaration.declarations[i];
+      if (declaration.init && declaration.init.type === 'NewExpression') {
+        let name = declaration.id.name;
+        let error = this.check(node, name, 'export-class-instance');
+        this.report(node, error, 'export-class-instance');
+        return error;
+      }
+    }
+  }
+
+  // 检测命名导出的类实例引用
+  if (node.specifiers && node.specifiers.length > 0) {
+    for (let i = 0; i < node.specifiers.length; i++) {
+      let specifier = node.specifiers[i];
+
+      // 检测导出的标识符（避免重复检测）
+      // 优先检测 exported 属性，如果存在则使用它，否则使用 local 属性
+      let identifier_to_check = null;
+      let identifier_name = '';
+      
+      if (specifier.exported && specifier.exported.type === 'Identifier') {
+        identifier_to_check = specifier.exported;
+        identifier_name = specifier.exported.name;
+      } else if (specifier.local && specifier.local.type === 'Identifier') {
+        identifier_to_check = specifier.local;
+        identifier_name = specifier.local.name;
+      }
+      
+      // 只有当找到有效标识符时才进行检测
+      if (identifier_to_check) {
+        let original_type = this._getOriginalType(specifier, 'ExportSpecifier');
+
+        // 只有当导出的是类实例时才检测
+        if (original_type === 'class-instance') {
+          let error = this.check(identifier_to_check, identifier_name, 'export-class-instance');
+          this.report(identifier_to_check, error, 'export-class-instance');
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  ClassInstanceName
+};