mm_eslint 1.0.2 → 1.0.3

package/index.js

@@ -1,1085 +1,1899 @@
-'use strict';
-
-/**
- * 命名规范检测器类
- */
-class Detector {
-  static config = {
-    forbidden_words: [
-      'manager', 'handler', 'processor', 'controller',
-      'Management', 'Handler', 'Processor', 'Controller',
-      'LoggerManager', 'AppState', 'UserHandler'
-    ],
-    regex: {
-      'PascalCase': /^[A-Z][a-zA-Z]*$/, // 大驼峰：大写字母开头，只包含字母。主要用于类名
-      'camelCase': /^[a-z][a-zA-Z]*$/, // 小驼峰：小写字母开头，只包含字母。主要用于方法名、函数名
-      'snake_case': /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写蛇形：小写字母开头，可包含下划线。主要用于变量名、入参名
-      'UPPER_SNAKE_CASE': /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/, // 大写蛇形：大写字母开头，可包含下划线。主要用于常量名
-      'kebab-case': /^[a-z][a-z0-9-]*(-[a-z0-9]+)*$/, // 小写横杠：小写字母开头，可包含短横线，小写短横线。主要用于资源名、路由路径
-      'UPPER-KEBAB-CASE': /^[A-Z][A-Z0-9-]*(-[A-Z0-9]+)*$/, // 大写横杠：大写字母开头，可包含短横线，大写短横线。主要用于资源名、路由路径
-      'lowercase': /^[a-z][a-z0-9]*$/, // 小写单词：小写字母开头，只包含小写字母和数字。主要用于对象、属性名
-      'UPPERCASE': /^[A-Z][A-Z0-9]*$/, // 大写单词：大写字母开头，只包含大写字母和数字。主要用于枚举值、常量名
-      'camelCase-kebab': /^[a-z][a-z0-9-]*(-[a-z0-9]+)*$/, // 支持横杠小驼峰：小写字母开头，可包含短横线，小写短横线。主要用于资源名、路由路径
-      'PascalCase-kebab': /^[A-Z][a-zA-Z]*$/, // 支持横杠大驼峰：大写字母开头，只包含字母。主要用于资源名、路由路径
-      '_camelCase': /^_[a-z][a-zA-Z]*$/, // 下划线小驼峰：下划线加小写字母开头，只包含字母。主要用于私有方法名
-      '_snake_case': /^_[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 下划线小写蛇形：下划线加小写字母开头，可包含下划线。主要用于私有变量名
-      '_lowercase': /^_[a-z][a-z0-9]*$/, // 下划线小写单词：下划线加小写字母开头，只包含小写字母和数字。主要用于对象、属性名
-    },
-
-    // 类名大驼峰规则
-    'class-name': {
-      name: '类名',
-      message: '必须使用大驼峰命名法（PascalCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ['PascalCase'],
-      single_word: true,
-      single_word_len: 8
-    },
-
-    // 函数名小驼峰规则
-    'function-name': {
-      name: '函数名',
-      message: '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ['camelCase'],
-      single_word: true,
-      single_word_len: 8
-    },
-
-    // 方法名小驼峰规则
-    'method-name': {
-      name: '方法名',
-      message: '必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符',
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ['camelCase'],
-      single_word: true,
-      single_word_len: 8
-    },
-
-    // 入参名小写蛇形规则
-    'param-name': {
-      name: '入参名',
-      message: '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符',
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ['lowercase', 'snake_case']
-    },
-
-    // 变量名小写蛇形规则
-    'variable-name': {
-      name: '变量名',
-      message: '必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符',
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ['lowercase', 'snake_case']
-    },
-
-    // 常量名大写蛇形规则
-    'constant-name': {
-      name: '常量名',
-      message: '必须使用大写蛇形命名法（UPPER_SNAKE_CASE），长度{min}-{max}字符',
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ['UPPERCASE', 'UPPER_SNAKE_CASE']
-    },
-
-    // 属性名多风格规则（根据值类型应用不同规则）
-    'property-name': {
-      name: '属性名',
-      message: '根据属性值类型应用不同命名规则',
-      min: 1,
-      max: 20,
-      single_word: true,
-      single_word_len: 8,
-      styles: ['lowercase', '_lowercase', 'UPPERCASE', 'snake_case', '_snake_case']
-    },
-
-    // 私有方法/属性规则
-    'private-naming': {
-      name: '私有成员',
-      message: '必须以单下划线开头，后跟小写蛇形命名，长度{min}-{max}字符',
-      regex: null, // 使用styles属性进行验证
-      min: 2,
-      max: 20,
-      styles: ['_lowercase', '_snake_case', '_camelCase']
-    }
-  }
-
-  constructor(config) {
-    // 合并默认配置和传入配置
-    const merged_config = { ...Detector.config };
-    if (config && typeof config === 'object') {
-      Object.keys(config).forEach(key => {
-        if (merged_config[key]) {
-          merged_config[key] = { ...merged_config[key], ...config[key] };
-          
-          // 处理字符串形式的正则表达式
-          if (typeof merged_config[key].regex === 'string') {
-            try {
-              // 从字符串中提取正则表达式模式和标志
-              const regex_match = merged_config[key].regex.match(/^\/(.*)\/([gimuy]*)$/);
-              if (regex_match) {
-                merged_config[key].regex = new RegExp(regex_match[1], regex_match[2]);
-              } else {
-                // 如果不是标准的正则表达式字符串格式，直接创建
-                merged_config[key].regex = new RegExp(merged_config[key].regex);
-              }
-            } catch (error) {
-              console.warn(`无效的正则表达式: ${merged_config[key].regex}`, error);
-              merged_config[key].regex = null;
-            }
-          }
-        }
-      });
-    }
-    this.config = merged_config;
-    this._init_rules();
-  }
-
-
-}
-
-/**
- * 创建新的规则模型
- * @returns {Object} 规则模型
- * @private
- */
-Detector.prototype._new_model = function () {
-  return {
-    name: '',
-    message: '',
-    regex: null,
-    min: 1,
-    max: 20
-  };
-}
-
-/**
- * 初始化规则检查方法
- * @private
- */
-Detector.prototype._init_rules = function () {
-  // 绑定规则检查方法
-  this._rules = {
-    'class-name': this._checkName.bind(this, 'class-name'),
-    'function-name': this._checkName.bind(this, 'function-name'),
-    'method-name': this._checkName.bind(this, 'method-name'),
-    'param-name': this._checkName.bind(this, 'param-name'),
-    'variable-name': this._checkName.bind(this, 'variable-name'),
-    'constant-name': this._checkName.bind(this, 'constant-name'),
-    'property-name': this._checkPropertyName.bind(this),
-    'private-naming': this._checkName.bind(this, 'private-naming')
-  };
-}
-
-/**
- * 通用命名检查方法
- * @param {string} rule_type - 规则类型
- * @param {string} name - 名称
- * @returns {Object} 检查结果
- * @private
- */
-Detector.prototype._checkName = function (rule_type, name) {
-  if (!name) {
-    throw new TypeError('名称不能为空');
-  }
-
-  const config = this.config[rule_type];
-  if (!config) {
-    throw new Error(`不支持的规则类型: ${rule_type}`);
-  }
-
-  const errors = [];
-  const warnings = [];
-
-  // 检查长度
-  if (name.length < config.min) {
-    errors.push(`${config.name}长度不能少于${config.min}个字符`);
-  }
-  if (name.length > config.max) {
-    errors.push(`${config.name}长度不能超过${config.max}个字符`);
-  }
-
-  // 检查命名规则（优先使用regex，如果regex为空则使用styles）
-  let name_valid = false;
-  
-  if (config.regex && config.regex.toString() !== '/(?:)/') {
-    // 使用regex进行验证
-    name_valid = config.regex.test(name);
-    if (!name_valid) {
-      const error_message = config.message
-        .replace('{name}', `"${name}"`)
-        .replace('{type}', config.name)
-        .replace('{min}', config.min)
-        .replace('{max}', config.max)
-        .replace('{word_len}', config.single_word_len || 8)
-        .replace('{regex}', config.regex.toString());
-      errors.push(error_message);
-    }
-  } else if (config.styles && config.styles.length > 0) {
-    // 使用styles进行验证
-    name_valid = this._checkNameByStyles(name, config.styles);
-    if (!name_valid) {
-      const allowed_styles = config.styles.join('、');
-      errors.push(`${config.name}必须符合以下命名风格之一：${allowed_styles}`);
-    }
-  } else {
-    // 既没有regex也没有styles，跳过命名格式检查
-    name_valid = true;
-  }
-
-  // 检查禁止词汇
-  if (this._hasForbiddenWords(name)) {
-    errors.push(`${config.name}包含禁止的废话词`);
-  }
-
-  // 检查是否优先使用单个单词（警告级别）
-  if (config.single_word) {
-    // 检测驼峰命名中的大写字母（表示多单词组合）
-    // 排除第一个字母后，检查是否包含大写字母（表示多单词）
-    const has_uppercase = /[A-Z]/.test(name.slice(1));
-    // 检测下划线或连字符
-    const has_separators = name.includes('_') || name.includes('-');
-    
-    // 对于函数名和方法名，需要更精确地检测多单词
-    // getName（get前缀+单个单词）不算多单词，getUserName（get前缀+多单词）才算多单词
-    const is_function_or_method = rule_type === 'function-name' || rule_type === 'method-name';
-    let is_multi_word = has_uppercase || has_separators;
-    
-    if (is_function_or_method && is_multi_word) {
-      // 检查是否是add/del/set/get/is/has等前缀后跟单个单词
-      const prefix_match = name.match(/^(add|del|set|get|is|has|can|not)([A-Z][a-z]*)$/);
-      if (prefix_match && prefix_match[2]) {
-        // 如果前缀后只有一个单词，不算多单词
-        is_multi_word = false;
-      }
-    }
-    
-    if (is_multi_word) {
-      warnings.push(`${config.name}应优先使用单个单词`);
-    }
-  }
-
-  // 检查单个单词长度限制
-  if (config.single_word_len && config.single_word_len > 0) {
-    const words = this._splitWords(name, rule_type);
-    const long_words = words.filter(word => word.length > config.single_word_len);
-    
-    if (long_words.length > 0) {
-      errors.push(`${config.name}中的单词"${long_words.join('、')}"超过${config.single_word_len}个字符限制`);
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors: errors,
-    warnings: warnings
-  };
-}
-
-/**
- * 根据styles列表检查名称是否符合命名风格
- * @param {string} name - 名称
- * @param {Array} styles - 命名风格列表
- * @returns {boolean} 是否符合任一风格
- * @private
- */
-Detector.prototype._checkNameByStyles = function (name, styles) {
-  if (!name || !styles || styles.length === 0) {
-    return false;
-  }
-
-  // 检查名称是否符合任一指定的命名风格
-  for (const style of styles) {
-    const regex = this.config.regex[style];
-    if (regex && regex.test(name)) {
-      return true;
-    }
-  }
-  
-  return false;
-}
-
-/**
- * 拆分名称中的单词
- * @param {string} name - 名称
- * @param {string} rule_type - 规则类型
- * @returns {Array} 拆分后的单词数组
- * @private
- */
-Detector.prototype._splitWords = function (name, rule_type) {
-  if (!name) {
-    return [];
-  }
-
-  const words = [];
-  
-  // 根据命名风格拆分单词
-  if (name.includes('_')) {
-    // 蛇形命名：user_name → ["user", "name"]
-    words.push(...name.split('_').filter(word => word.length > 0));
-  } else if (name.includes('-')) {
-    // 横杠命名：user-name → ["user", "name"]
-    words.push(...name.split('-').filter(word => word.length > 0));
-  } else {
-    // 驼峰命名：userName → ["user", "Name"]
-    // 使用正则表达式拆分驼峰命名
-    const camel_case_words = name.split(/(?=[A-Z])/);
-    
-    // 对于函数名和方法名，处理常见前缀
-    if (rule_type === 'function-name' || rule_type === 'method-name') {
-      const prefix_match = name.match(/^(add|del|set|get|is|has|can|not)([A-Z].*)$/);
-      if (prefix_match) {
-        // 如果是前缀+单词的组合，将前缀作为单独单词
-        words.push(prefix_match[1]);
-        // 拆分剩余部分
-        const remaining_words = prefix_match[2].split(/(?=[A-Z])/);
-        words.push(...remaining_words);
-      } else {
-        words.push(...camel_case_words);
-      }
-    } else {
-      words.push(...camel_case_words);
-    }
-  }
-  
-  // 过滤空字符串并转换为小写进行比较
-  return words.filter(word => word.length > 0).map(word => word.toLowerCase());
-}
-
-/**
- * 属性名检查方法（根据属性值类型应用不同规则）
- * @param {string} name - 属性名
- * @param {Object} value_node - 属性值AST节点
- * @returns {Object} 检查结果
- * @private
- */
-Detector.prototype._checkPropertyName = function (name, value_node) {
-  if (!name) {
-    throw new TypeError('属性名不能为空');
-  }
-
-  const config = this.config['property-name'];
-  if (!config) {
-    throw new Error('属性名规则配置不存在');
-  }
-
-  const errors = [];
-  const warnings = [];
-
-  // 检查长度
-  if (name.length < config.min) {
-    errors.push(`${config.name}长度不能少于${config.min}个字符`);
-  }
-  if (name.length > config.max) {
-    errors.push(`${config.name}长度不能超过${config.max}个字符`);
-  }
-
-  // 检查禁止词汇
-  if (this._hasForbiddenWords(name)) {
-    errors.push(`${config.name}包含禁止的废话词`);
-  }
-
-  // 根据属性值类型应用不同的命名规则
-  const value_type = this._getPropertyValueType(value_node);
-  
-  switch (value_type) {
-    case 'function':
-      // 函数属性：使用函数名检测规则
-      const function_result = this._checkName('function-name', name);
-      if (!function_result.valid) {
-        errors.push(`${config.name}（函数属性）${function_result.errors.join(', ')}`);
-      }
-      break;
-      
-    case 'class':
-      // 类属性：使用类名检测规则
-      const class_result = this._checkName('class-name', name);
-      if (!class_result.valid) {
-        errors.push(`${config.name}（类属性）${class_result.errors.join(', ')}`);
-      }
-      break;
-      
-    case 'value':
-    default:
-      // 值属性：使用styles配置检查命名风格
-      const is_uppercase_snake = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)+$/.test(name); // 包含下划线的大写蛇形
-      const is_uppercase_multi = /^[A-Z][A-Z0-9]*[A-Z][A-Z0-9]*$/.test(name); // 多单词大写组合（没有下划线）
-
-      // 检查是否为大写蛇形（禁止）
-      if (is_uppercase_snake || is_uppercase_multi) {
-        errors.push(`${config.name}（值属性）禁止使用大写蛇形命名（如PRODUCT_ID或PRODUCTID）`);
-      }
-
-      // 使用styles配置检查命名风格
-      if (config.styles && config.styles.length > 0) {
-        const is_valid_style = this._checkNameByStyles(name, config.styles);
-        if (!is_valid_style && !is_uppercase_snake && !is_uppercase_multi) {
-          const allowed_styles = config.styles.join('、');
-          errors.push(`${config.name}（值属性）必须符合以下命名风格之一：${allowed_styles}`);
-        }
-      }
-      break;
-  }
-
-  // 检查是否优先使用单个单词（警告级别）
-  if (config.single_word) {
-    // 检测驼峰命名中的大写字母（表示多单词组合）
-    const has_uppercase = /[A-Z]/.test(name.slice(1));
-    // 检测下划线或连字符
-    const has_separators = name.includes('_') || name.includes('-');
-    
-    if (has_uppercase || has_separators) {
-      warnings.push(`${config.name}应优先使用单个单词`);
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors: errors,
-    warnings: warnings,
-    value_type: value_type
-  };
-}
-
-/**
- * 获取属性值类型
- * @param {Object} value_node - 属性值AST节点
- * @returns {string} 属性值类型（'function', 'class', 'value'）
- * @private
- */
-Detector.prototype._getPropertyValueType = function (value_node) {
-  if (!value_node) {
-    return 'value'; // 默认值类型
-  }
-
-  // 检查是否为函数
-  if (value_node.type === 'FunctionExpression' || 
-      value_node.type === 'ArrowFunctionExpression' ||
-      (value_node.type === 'Identifier' && value_node.name && 
-       (value_node.name.endsWith('Function') || value_node.name.endsWith('Func') ||
-        value_node.name.startsWith('on') || value_node.name.startsWith('handle')))) {
-    return 'function';
-  }
-
-  // 检查是否为类
-  if (value_node.type === 'ClassExpression' ||
-      (value_node.type === 'Identifier' && value_node.name && 
-       /^[A-Z][a-zA-Z]*$/.test(value_node.name))) {
-    return 'class';
-  }
-
-  // 默认为值类型
-  return 'value';
-}
-
-/**
- * 检查是否包含禁止的废话词
- * @param {string} name - 名称
- * @returns {boolean} 是否包含禁止词
- * @private
- */
-Detector.prototype._hasForbiddenWords = function (name) {
-  if (!name) {
-    return false;
-  }
-
-  const forbidden_words = this.config.forbidden_words || [];
-
-  return forbidden_words.some(word =>
-    name.toLowerCase().includes(word.toLowerCase())
-  );
-}
-
-/**
- * 检测名称是否符合规范
- * @param {string} name - 名称
- * @param {string} type - 类型（class/function/variable/constant/private）
- * @returns {Object} 检测结果
- */
-Detector.prototype.checkName = function (name, type) {
-  if (typeof name !== 'string' || !name.trim()) {
-    return {
-      valid: false,
-      errors: ['名称必须是有效的字符串']
-    };
-  }
-
-  if (typeof type !== 'string' || !type.trim()) {
-    return {
-      valid: false,
-      errors: ['类型必须是有效的字符串']
-    };
-  }
-
-  const rule_method = this._rules[type];
-  if (!rule_method) {
-    return {
-      valid: false,
-      errors: [`不支持的类型: ${type}`]
-    };
-  }
-
-  try {
-    return rule_method(name);
-  } catch (error) {
-    return {
-      valid: false,
-      errors: [`检测名称时出错: ${error.message}`]
-    };
-  }
-}
-
-/**
- * 批量检测名称
- * @param {Array} names - 名称数组
- * @param {string} type - 类型
- * @returns {Array} 检测结果数组
- */
-Detector.prototype.checkNames = function (names, type) {
-  if (!Array.isArray(names)) {
-    throw new TypeError('名称必须是数组');
-  }
-
-  return names.map(name => this.check_name(name, type));
-}
-
-/**
- * ESLint规则实现
- */
-
-/**
- * 类名大驼峰规则
- */
-const class_name_rule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: '类名必须使用大驼峰命名法（PascalCase）且优先使用单个单词',
-      category: 'Stylistic Issues',
-      recommended: true
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          regex: { type: 'string' },
-          min: { type: 'number' },
-          max: { type: 'number' },
-          message: { type: 'string' },
-          single_word: { type: 'boolean' },
-          single_word_len: { type: 'number' },
-          styles: { type: 'array', items: { type: 'string' } }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      ClassDeclaration(node) {
-        const class_name = node.id.name;
-        const detector = new Detector({ 'class-name': options });
-        const result = detector.checkName(class_name, 'class-name');
-
-        if (!result.valid) {
-          result.errors.forEach(error => {
-            context.report({
-              node: node.id,
-              message: `类名"${class_name}"不符合规范: ${error}`
-            });
-          });
-        }
-      }
-    };
-  }
-};
-
-/**
- * 函数名小驼峰规则
- */
-const function_name_rule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: '函数名必须使用小驼峰命名法（camelCase）且优先使用单个单词',
-      category: 'Stylistic Issues',
-      recommended: true
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          regex: { type: 'string' },
-          min: { type: 'number' },
-          max: { type: 'number' },
-          message: { type: 'string' },
-          single_word: { type: 'boolean' },
-          single_word_len: { type: 'number' },
-          styles: { type: 'array', items: { type: 'string' } }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      FunctionDeclaration(node) {
-        const function_name = node.id ? node.id.name : 'anonymous';
-        if (function_name !== 'anonymous') {
-          const detector = new Detector({ 'function-name': options });
-          const result = detector.checkName(function_name, 'function-name');
-
-          if (!result.valid) {
-            result.errors.forEach(error => {
-              context.report({
-                node: node.id,
-                message: `函数名"${function_name}"不符合规范: ${error}`
-              });
-            });
-          }
-        }
-      },
-
-      FunctionExpression(node) {
-        if (node.id) {
-          const function_name = node.id.name;
-          const detector = new Detector({ 'function-name': options });
-          const result = detector.checkName(function_name, 'function-name');
-
-          if (!result.valid) {
-            result.errors.forEach(error => {
-              context.report({
-                node: node.id,
-                message: `函数表达式名"${function_name}"不符合规范: ${error}`
-              });
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-/**
- * 方法名小驼峰规则
- */
-const method_name_rule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: '方法名必须使用小驼峰命名法（camelCase）且优先使用单个单词',
-      category: 'Stylistic Issues',
-      recommended: true
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          regex: { type: 'string' },
-          min: { type: 'number' },
-          max: { type: 'number' },
-          message: { type: 'string' },
-          single_word: { type: 'boolean' },
-          single_word_len: { type: 'number' },
-          styles: { type: 'array', items: { type: 'string' } }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      MethodDefinition(node) {
-        const method_name = node.key.name;
-        
-        // 跳过私有方法的检测（私有方法由private-naming规则处理）
-        if (method_name.startsWith('_')) {
-          return;
-        }
-        
-        const detector = new Detector({ 'method-name': options });
-        const result = detector.checkName(method_name, 'method-name');
-
-        if (!result.valid) {
-          result.errors.forEach(error => {
-            context.report({
-              node: node.key,
-              message: `方法名"${method_name}"不符合规范: ${error}`
-            });
-          });
-        }
-      }
-    };
-  }
-};
-
-/**
- * 变量名小写蛇形规则
- */
-const variable_name_rule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: '变量名必须使用小写蛇形命名法（snake_case）',
-      category: 'Stylistic Issues',
-      recommended: true
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          regex: { type: 'string' },
-          min: { type: 'number' },
-          max: { type: 'number' },
-          message: { type: 'string' },
-          single_word: { type: 'boolean' },
-          single_word_len: { type: 'number' },
-          styles: { type: 'array', items: { type: 'string' } }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    
-    function isRealConstant(node) {
-      // 真正的常量特征：
-      // 1. 在模块顶层作用域（不在函数或块内）
-      // 2. 名称包含大写字母（表示意图作为常量）
-      
-      // 检查是否在模块顶层
-      let scope_node = node;
-      while (scope_node.parent) {
-        scope_node = scope_node.parent;
-        if (scope_node.type === 'FunctionDeclaration' || 
-            scope_node.type === 'FunctionExpression' ||
-            scope_node.type === 'ArrowFunctionExpression' ||
-            scope_node.type === 'BlockStatement') {
-          return false; // 在函数或块内，不是真正的常量
-        }
-      }
-      
-      // 检查名称是否包含大写字母（表示意图作为常量）
-      const name = node.id.name;
-      return /[A-Z]/.test(name);
-    }
-    
-    return {
-      VariableDeclarator(node) {
-        if (node.id.type === 'Identifier') {
-          // 对于const声明，只对不是真正常量的应用变量命名规则
-          if (node.parent.kind === 'const' && isRealConstant(node)) {
-            return; // 这是真正的常量，由常量规则处理
-          }
-          
-          const variable_name = node.id.name;
-          const detector = new Detector({ 'variable-name': options });
-          const result = detector.checkName(variable_name, 'variable-name');
-
-          if (!result.valid) {
-            result.errors.forEach(error => {
-              context.report({
-                node: node.id,
-                message: `变量名"${variable_name}"不符合规范: ${error}`
-              });
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-/**
- * 常量名大写蛇形规则
- */
-const constant_name_rule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: '常量名必须使用大写蛇形命名法（UPPER_SNAKE_CASE）',
-      category: 'Stylistic Issues',
-      recommended: true
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          regex: { type: 'string' },
-          min: { type: 'number' },
-          max: { type: 'number' },
-          message: { type: 'string' },
-          single_word: { type: 'boolean' },
-          single_word_len: { type: 'number' },
-          styles: { type: 'array', items: { type: 'string' } }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    
-    function isRealConstant(node) {
-      // 真正的常量特征：
-      // 1. 在模块顶层作用域（不在函数或块内）
-      // 2. 名称包含大写字母（表示意图作为常量）
-      // 3. 或者名称是常见的常量模式（如全大写）
-      
-      // 检查是否在模块顶层
-      let scope_node = node;
-      while (scope_node.parent) {
-        scope_node = scope_node.parent;
-        if (scope_node.type === 'FunctionDeclaration' || 
-            scope_node.type === 'FunctionExpression' ||
-            scope_node.type === 'ArrowFunctionExpression' ||
-            scope_node.type === 'BlockStatement') {
-          return false; // 在函数或块内，不是真正的常量
-        }
-      }
-      
-      // 检查名称是否包含大写字母（表示意图作为常量）
-      const name = node.id.name;
-      return /[A-Z]/.test(name);
-    }
-    
-    return {
-      VariableDeclarator(node) {
-        if (node.id.type === 'Identifier' && node.parent.kind === 'const') {
-          // 只对真正的常量应用常量命名规则
-          if (isRealConstant(node)) {
-            const constant_name = node.id.name;
-            const detector = new Detector({ 'constant-name': options });
-            const result = detector.checkName(constant_name, 'constant-name');
-
-            if (!result.valid) {
-              result.errors.forEach(error => {
-                context.report({
-                  node: node.id,
-                  message: `常量名"${constant_name}"不符合规范: ${error}`
-                });
-              });
-            }
-          }
-        }
-      }
-    };
-  }
-};
-
-/**
- * 入参名小写蛇形规则
- */
-const param_name_rule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: '入参名必须使用小写蛇形命名法（snake_case）',
-      category: 'Stylistic Issues',
-      recommended: true
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          regex: { type: 'string' },
-          min: { type: 'number' },
-          max: { type: 'number' },
-          message: { type: 'string' },
-          single_word: { type: 'boolean' },
-          single_word_len: { type: 'number' },
-          styles: { type: 'array', items: { type: 'string' } }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    
-    function checkParam(node) {
-      node.params.forEach(param => {
-        if (param.type === 'Identifier') {
-          const param_name = param.name;
-          const detector = new Detector({ 'param-name': options });
-          const result = detector.checkName(param_name, 'param-name');
-
-          if (!result.valid) {
-            result.errors.forEach(error => {
-              context.report({
-                node: param,
-                message: `入参名"${param_name}"不符合规范: ${error}`
-              });
-            });
-          }
-        }
-      });
-    }
-    
-    return {
-      FunctionDeclaration: checkParam,
-      FunctionExpression: checkParam,
-      ArrowFunctionExpression: checkParam
-    };
-  }
-};
-
-/**
- * 属性名小写蛇形规则
- */
-const property_name_rule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: '属性名必须使用小写蛇形命名法（snake_case）',
-      category: 'Stylistic Issues',
-      recommended: true
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          regex: { type: 'string' },
-          min: { type: 'number' },
-          max: { type: 'number' },
-          message: { type: 'string' },
-          single_word: { type: 'boolean' },
-          single_word_len: { type: 'number' },
-          styles: { type: 'array', items: { type: 'string' } }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      Property(node) {
-        // 检测类属性、对象字面量属性、模块导出属性
-        const is_class_property = node.parent && 
-          (node.parent.type === 'ClassBody' || 
-           (node.parent.type === 'ObjectExpression' && 
-            node.parent.parent && 
-            node.parent.parent.type === 'ClassDeclaration'));
-        
-        const is_object_property = node.parent && node.parent.type === 'ObjectExpression';
-        
-        // 检测所有非私有属性（不以_开头）
-        if (node.key.type === 'Identifier' && !node.key.name.startsWith('_')) {
-          const property_name = node.key.name;
-          const detector = new Detector({ 'property-name': options });
-          const result = detector._checkPropertyName(property_name, node.value);
-
-          if (!result.valid) {
-            result.errors.forEach(error => {
-              context.report({
-                node: node.key,
-                message: `属性名"${property_name}"不符合规范: ${error}`
-              });
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-/**
- * 私有成员命名规则
- */
-const private_naming_rule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: '私有成员必须以单下划线开头，后跟小写蛇形命名',
-      category: 'Stylistic Issues',
-      recommended: true
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          regex: { type: 'string' },
-          min: { type: 'number' },
-          max: { type: 'number' },
-          message: { type: 'string' },
-          single_word: { type: 'boolean' },
-          single_word_len: { type: 'number' },
-          styles: { type: 'array', items: { type: 'string' } }
-        },
-        additionalProperties: false
-      }
-    ]
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      MethodDefinition(node) {
-        const method_name = node.key.name;
-        if (method_name.startsWith('_')) {
-          const detector = new Detector({ 'private-naming': options });
-          const result = detector.checkName(method_name, 'private-naming');
-
-          if (!result.valid) {
-            result.errors.forEach(error => {
-              context.report({
-                node: node.key,
-                message: `私有方法名"${method_name}"不符合规范: ${error}`
-              });
-            });
-          }
-        }
-      },
-
-      Property(node) {
-        if (node.key.type === 'Identifier' && node.key.name.startsWith('_')) {
-          const private_name = node.key.name;
-          const detector = new Detector({ 'private-naming': options });
-          const result = detector.checkName(private_name, 'private-naming');
-
-          if (!result.valid) {
-            result.errors.forEach(error => {
-              context.report({
-                node: node.key,
-                message: `私有属性名"${private_name}"不符合规范: ${error}`
-              });
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-/**
- * 命名规范ESLint插件
- */
-const naming_rules = {
-  'class-name': class_name_rule,
-  'function-name': function_name_rule,
-  'method-name': method_name_rule,
-  'variable-name': variable_name_rule,
-  'constant-name': constant_name_rule,
-  'private-naming': private_naming_rule,
-  'param-name': param_name_rule,
-  'property-name': property_name_rule
-};
-
-module.exports = {
-  Detector,
-  rules: naming_rules
-};
+"use strict";
+
+/**
+ * 命名规范检测器类
+ */
+class Detector {
+  static config = {
+    forbidden_words: [
+      "manager",
+      "handler",
+      "processor",
+      "controller",
+      "Management",
+      "Handler",
+      "Processor",
+      "Controller",
+      "LoggerManager",
+      "AppState",
+      "UserHandler",
+    ],
+    regex: {
+      PascalCase: /^[A-Z][a-zA-Z]*$/, // 大驼峰：大写字母开头，只包含字母。主要用于类名
+      camelCase: /^[a-z][a-zA-Z]*$/, // 小驼峰：小写字母开头，只包含字母。主要用于方法名、函数名
+      snake_case: /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写蛇形：小写字母开头，可包含下划线。主要用于变量名、入参名
+      UPPER_SNAKE_CASE: /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/, // 大写蛇形：大写字母开头，可包含下划线。主要用于常量名
+      "kebab-case": /^[a-z][a-z0-9-]*(-[a-z0-9]+)*$/, // 小写横杠：小写字母开头，可包含短横线，小写短横线。主要用于资源名、路由路径
+      "UPPER-KEBAB-CASE": /^[A-Z][A-Z0-9-]*(-[A-Z0-9]+)*$/, // 大写横杠：大写字母开头，可包含短横线，大写短横线。主要用于资源名、路由路径
+      lowercase: /^[a-z][a-z0-9]*$/, // 小写单词：小写字母开头，只包含小写字母和数字。主要用于对象、属性名
+      UPPERCASE: /^[A-Z][A-Z0-9]*$/, // 大写单词：大写字母开头，只包含大写字母和数字。主要用于枚举值、常量名
+      "camelCase-kebab": /^[a-z][a-z0-9-]*(-[a-z0-9]+)*$/, // 支持横杠小驼峰：小写字母开头，可包含短横线，小写短横线。主要用于资源名、路由路径
+      "PascalCase-kebab": /^[A-Z][a-zA-Z]*$/, // 支持横杠大驼峰：大写字母开头，只包含字母。主要用于资源名、路由路径
+      _camelCase: /^_[a-z][a-zA-Z]*$/, // 下划线小驼峰：下划线加小写字母开头，只包含字母。主要用于私有方法名
+      _snake_case: /^_[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 下划线小写蛇形：下划线加小写字母开头，可包含下划线。主要用于私有变量名
+      _lowercase: /^_[a-z][a-z0-9]*$/, // 下划线小写单词：下划线加小写字母开头，只包含小写字母和数字。主要用于对象、属性名
+    },
+
+    // 类名大驼峰规则
+    "class-name": {
+      name: "类名",
+      message:
+        "必须使用大驼峰命名法（PascalCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
+      regex: null, // 使用styles属性进行验证
+      min: 1,
+      max: 20,
+      styles: ["PascalCase"],
+      single_word: true,
+      single_word_len: 8,
+    },
+
+    // 函数名小驼峰规则
+    "function-name": {
+      name: "函数名",
+      message:
+        "必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
+      regex: null, // 使用styles属性进行验证
+      min: 1,
+      max: 20,
+      styles: ["camelCase"],
+      single_word: true,
+      single_word_len: 8,
+    },
+
+    // 方法名小驼峰规则
+    "method-name": {
+      name: "方法名",
+      message:
+        "必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
+      regex: null, // 使用styles属性进行验证
+      min: 1,
+      max: 20,
+      styles: ["camelCase"],
+      single_word: true,
+      single_word_len: 8,
+    },
+
+    // 入参名小写蛇形规则
+    "param-name": {
+      name: "入参名",
+      message:
+        "必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
+      regex: null, // 使用styles属性进行验证
+      min: 1,
+      max: 20,
+      styles: ["lowercase", "snake_case"],
+      single_word: true,
+      single_word_len: 8,
+    },
+
+    // 变量名小写蛇形规则
+    "variable-name": {
+      name: "变量名",
+      message:
+        "必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
+      regex: null, // 使用styles属性进行验证
+      min: 1,
+      max: 20,
+      styles: ["lowercase", "snake_case"],
+      single_word: true,
+      single_word_len: 8,
+    },
+
+    // 常量名大写蛇形规则
+    "constant-name": {
+      name: "常量名",
+      message:
+        "必须使用大写蛇形命名法（UPPER_SNAKE_CASE），长度{min}-{max}字符",
+      regex: null, // 使用styles属性进行验证
+      min: 1,
+      max: 20,
+      styles: ["UPPERCASE", "UPPER_SNAKE_CASE"],
+    },
+
+    // 属性名多风格规则（根据值类型应用不同规则）
+    "property-name": {
+      name: "属性名",
+      message: "根据属性值类型应用不同命名规则",
+      min: 1,
+      max: 20,
+      single_word: true,
+      single_word_len: 8,
+      styles: [
+        "lowercase",
+        "_lowercase",
+        "snake_case",
+        "_snake_case",
+        "UPPERCASE",
+        "UPPER_SNAKE_CASE",
+        "PascalCase",
+      ],
+      strong: true, // 强验证模式：根据属性值类型智能判断；false：弱验证模式：只需符合变量名或常量名规则
+    },
+
+    // 私有方法规则
+    "private-method-naming": {
+      name: "私有方法",
+      message:
+        "必须以单下划线开头，后跟小驼峰命名或小写单词，长度{min}-{max}字符",
+      regex: null, // 使用styles属性进行验证
+      min: 2,
+      max: 20,
+      styles: ["_lowercase", "_camelCase"],
+    },
+
+    // 私有变量规则
+    "private-variable-naming": {
+      name: "私有变量",
+      message:
+        "必须以单下划线开头，后跟小写蛇形命名或小写单词，长度{min}-{max}字符",
+      regex: null, // 使用styles属性进行验证
+      min: 2,
+      max: 20,
+      styles: ["_lowercase", "_snake_case"],
+    },
+  };
+
+  constructor(config) {
+    // 合并默认配置和传入配置
+    const merged_cfg = { ...Detector.config };
+    if (config && typeof config === "object") {
+      Object.keys(config).forEach((key) => {
+        if (merged_cfg[key]) {
+          merged_cfg[key] = { ...merged_cfg[key], ...config[key] };
+
+          // 处理字符串形式的正则表达式
+          if (typeof merged_cfg[key].regex === "string") {
+            try {
+              // 从字符串中提取正则表达式模式和标志
+              const regex_match =
+                merged_cfg[key].regex.match(/^\/(.*)\/([gimuy]*)$/);
+              if (regex_match) {
+                merged_cfg[key].regex = new RegExp(
+                  regex_match[1],
+                  regex_match[2],
+                );
+              } else {
+                // 如果不是标准的正则表达式字符串格式，直接创建
+                merged_cfg[key].regex = new RegExp(merged_cfg[key].regex);
+              }
+            } catch (error) {
+              console.warn(`无效的正则表达式: ${merged_cfg[key].regex}`, error);
+              merged_cfg[key].regex = null;
+            }
+          }
+        }
+      });
+    }
+    this.config = merged_cfg;
+    this._initRule();
+  }
+}
+
+/**
+ * 创建新的规则模型
+ * @returns {Object} 规则模型
+ * @private
+ */
+Detector.prototype._newModel = function () {
+  return {
+    name: "",
+    message: "",
+    regex: null,
+    min: 1,
+    max: 20,
+  };
+};
+
+/**
+ * 初始化规则检查方法
+ * @private
+ */
+Detector.prototype._initRule = function () {
+  // 绑定规则检查方法
+  this._rules = {
+    "class-name": this._checkName.bind(this, "class-name"),
+    "function-name": this._checkName.bind(this, "function-name"),
+    "method-name": this._checkName.bind(this, "method-name"),
+    "param-name": this._checkName.bind(this, "param-name"),
+    "variable-name": this._checkName.bind(this, "variable-name"),
+    "constant-name": this._checkName.bind(this, "constant-name"),
+    "property-name": this._checkPropName.bind(this),
+    "private-method-naming": this._checkName.bind(
+      this,
+      "private-method-naming",
+    ),
+    "private-variable-naming": this._checkName.bind(
+      this,
+      "private-variable-naming",
+    ),
+  };
+};
+
+/**
+ * 通用命名检查方法
+ * @param {string} rule_type - 规则类型
+ * @param {string} name - 名称
+ * @returns {Object} 检查结果
+ * @private
+ */
+Detector.prototype._checkName = function (rule_type, name) {
+  if (!name) {
+    throw new TypeError("名称不能为空");
+  }
+
+  const config = this.config[rule_type];
+  if (!config) {
+    throw new Error(`不支持的规则类型: ${rule_type}`);
+  }
+
+  const errors = [];
+  const warnings = [];
+
+  this._checkNameLength(name, config, errors);
+  this._checkNameFormat(name, rule_type, config, errors);
+  this._checkBadWords(name, config, errors);
+  this._checkSingleWord(name, rule_type, config, warnings);
+  this._checkWordLength(name, rule_type, config, errors);
+
+  return {
+    valid: errors.length === 0,
+    errors: errors,
+    warnings: warnings,
+  };
+};
+
+/**
+ * 检查名称长度限制
+ * @private
+ */
+Detector.prototype._checkNameLength = function (name, config, errors) {
+  if (name.length < config.min) {
+    errors.push(`${config.name}长度不能少于${config.min}个字符`);
+  }
+  if (name.length > config.max) {
+    errors.push(`${config.name}长度不能超过${config.max}个字符`);
+  }
+};
+
+/**
+ * 检查名称格式
+ * @private
+ */
+Detector.prototype._checkNameFormat = function (
+  name,
+  rule_type,
+  config,
+  errors,
+) {
+  let name_valid = false;
+
+  if (config.regex && config.regex.toString() !== "/(?:)/") {
+    name_valid = config.regex.test(name);
+    if (!name_valid) {
+      const error_message = config.message
+        .replace("{name}", `"${name}"`)
+        .replace("{type}", config.name)
+        .replace("{min}", config.min)
+        .replace("{max}", config.max)
+        .replace("{word_len}", config.single_word_len || 8)
+        .replace("{regex}", config.regex.toString());
+      errors.push(error_message);
+    }
+  } else if (config.styles && config.styles.length > 0) {
+    name_valid = this._checkStyle(name, config.styles);
+    if (!name_valid) {
+      const allowed_styles = config.styles.join("、");
+      errors.push(`${config.name}必须符合以下命名风格之一：${allowed_styles}`);
+    }
+  } else {
+    name_valid = true;
+  }
+};
+
+/**
+ * 检查禁止词汇
+ * @private
+ */
+Detector.prototype._checkBadWords = function (name, config, errors) {
+  if (this._hasBadWord(name)) {
+    errors.push(`${config.name}包含禁止的废话词`);
+  }
+};
+
+/**
+ * 检查是否优先使用单个单词
+ * @private
+ */
+Detector.prototype._checkSingleWord = function (
+  name,
+  rule_type,
+  config,
+  warnings,
+) {
+  if (!config.single_word) return;
+
+  const has_uppercase = /[A-Z]/.test(name.slice(1));
+  const has_separators = name.includes("_") || name.includes("-");
+  const is_func_or_method =
+    rule_type === "function-name" || rule_type === "method-name";
+  let is_multi_word = has_uppercase || has_separators;
+
+  if (is_func_or_method && is_multi_word) {
+    const prefix_match = name.match(
+      /^(add|del|set|get|is|has|can|not)([A-Z][a-z]*)$/,
+    );
+    if (prefix_match && prefix_match[2]) {
+      is_multi_word = false;
+    }
+  }
+
+  if (is_multi_word) {
+    warnings.push(`${config.name}应优先使用单个单词`);
+  }
+};
+
+/**
+ * 检查单词长度限制
+ * @private
+ */
+Detector.prototype._checkWordLength = function (
+  name,
+  rule_type,
+  config,
+  errors,
+) {
+  if (!config.single_word_len || config.single_word_len <= 0) return;
+
+  const words = this._splitWords(name, rule_type);
+  const long_words = words.filter(
+    (word) => word.length > config.single_word_len,
+  );
+
+  if (long_words.length > 0) {
+    errors.push(
+      `${config.name}中的单词"${long_words.join("、")}"超过${config.single_word_len}个字符限制`,
+    );
+  }
+};
+
+/**
+ * 根据styles列表检查名称是否符合命名风格
+ * @param {string} name - 名称
+ * @param {Array} styles - 命名风格列表
+ * @returns {boolean} 是否符合任一风格
+ * @private
+ */
+Detector.prototype._checkStyle = function (name, styles) {
+  if (!name || !styles || styles.length === 0) {
+    return false;
+  }
+
+  // 检查名称是否符合任一指定的命名风格
+  for (const style of styles) {
+    const regex = this.config.regex[style];
+    if (regex && regex.test(name)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+/**
+ * 拆分名称中的单词
+ * @param {string} name - 名称
+ * @param {string} rule_type - 规则类型
+ * @returns {Array} 拆分后的单词数组
+ * @private
+ */
+Detector.prototype._splitWords = function (name, rule_type) {
+  if (!name) {
+    return [];
+  }
+
+  const words = [];
+
+  // 根据命名风格拆分单词
+  if (name.includes("_")) {
+    // 蛇形命名：user_name → ["user", "name"]
+    words.push(...name.split("_").filter((word) => word.length > 0));
+  } else if (name.includes("-")) {
+    // 横杠命名：user-name → ["user", "name"]
+    words.push(...name.split("-").filter((word) => word.length > 0));
+  } else {
+    // 检查是否是纯小写单词（不包含大写字母）
+    if (!/[A-Z]/.test(name)) {
+      // 纯小写单词：configuration → ["configuration"]
+      words.push(name);
+    } else {
+      // 驼峰命名：userName → ["user", "Name"]
+      // 使用正则表达式拆分驼峰命名
+      const camel_case_words = name.split(/(?=[A-Z])/);
+
+      // 对于函数名和方法名，处理常见前缀
+      if (rule_type === "function-name" || rule_type === "method-name") {
+        const prefix_match = name.match(
+          /^(add|del|set|get|is|has|can|not)([A-Z].*)$/,
+        );
+        if (prefix_match) {
+          // 如果是前缀+单词的组合，将前缀作为单独单词
+          words.push(prefix_match[1]);
+          // 拆分剩余部分
+          const remaining_words = prefix_match[2].split(/(?=[A-Z])/);
+          words.push(...remaining_words);
+        } else {
+          words.push(...camel_case_words);
+        }
+      } else {
+        words.push(...camel_case_words);
+      }
+    }
+  }
+
+  // 过滤空字符串并转换为小写进行比较
+  return words
+    .filter((word) => word.length > 0)
+    .map((word) => word.toLowerCase());
+};
+
+/**
+ * 属性名检查方法（根据属性值类型应用不同规则）
+ * @param {string} name - 属性名
+ * @param {Object} val_node - 属性值AST节点
+ * @returns {Object} 检查结果
+ * @private
+ */
+Detector.prototype._checkPropName = function (name, val_node) {
+  if (!name) {
+    throw new TypeError("属性名不能为空");
+  }
+
+  const config = this.config["property-name"];
+  if (!config) {
+    throw new Error("属性名规则配置不存在");
+  }
+
+  const errors = [];
+  const warnings = [];
+
+  this._checkPropLength(name, config, errors);
+  this._checkBadWords(name, config, errors);
+
+  const use_strong_val = config.strong !== false;
+  const val_type = this._getPropType(val_node, name);
+
+  if (use_strong_val) {
+    this._checkPropStrong(name, val_type, config, errors);
+  } else {
+    this._checkPropWeak(name, val_type, config, errors);
+  }
+
+  this._checkPropSingleWord(name, config, warnings);
+
+  return {
+    valid: errors.length === 0,
+    errors: errors,
+    warnings: warnings,
+    value_type: val_type,
+  };
+};
+
+/**
+ * 检查属性名长度
+ * @private
+ */
+Detector.prototype._checkPropLength = function (name, config, errors) {
+  if (name.length < config.min) {
+    errors.push(`${config.name}长度不能少于${config.min}个字符`);
+  }
+  if (name.length > config.max) {
+    errors.push(`${config.name}长度不能超过${config.max}个字符`);
+  }
+};
+
+/**
+ * 强验证模式检查
+ * @private
+ */
+Detector.prototype._checkPropStrong = function (
+  name,
+  val_type,
+  config,
+  errors,
+) {
+  switch (val_type) {
+    case "function":
+      this._checkFuncProp(name, config, errors);
+      break;
+    case "class":
+      this._checkClassProp(name, config, errors);
+      break;
+    case "constant":
+      this._checkConstProp(name, config, errors);
+      break;
+    case "value":
+    default:
+      this._checkValueProp(name, config, errors);
+      break;
+  }
+};
+
+/**
+ * 弱验证模式检查
+ * @private
+ */
+Detector.prototype._checkPropWeak = function (name, val_type, config, errors) {
+  switch (val_type) {
+    case "function":
+      this._checkFuncProp(name, config, errors);
+      break;
+    case "class":
+      this._checkClassProp(name, config, errors);
+      break;
+    case "constant":
+    case "value":
+    default:
+      this._checkWeakValue(name, config, errors);
+      break;
+  }
+};
+
+/**
+ * 检查函数属性
+ * @private
+ */
+Detector.prototype._checkFuncProp = function (name, config, errors) {
+  const func_res = this._checkName("function-name", name);
+  if (!func_res.valid) {
+    errors.push(`${config.name}（函数）${func_res.errors.join(", ")}`);
+  }
+};
+
+/**
+ * 检查类属性
+ * @private
+ */
+Detector.prototype._checkClassProp = function (name, config, errors) {
+  const cls_res = this._checkName("class-name", name);
+  if (!cls_res.valid) {
+    errors.push(`${config.name}（类）${cls_res.errors.join(", ")}`);
+  }
+};
+
+/**
+ * 检查常量属性
+ * @private
+ */
+Detector.prototype._checkConstProp = function (name, config, errors) {
+  const is_valid_const = this._checkStyle(name, [
+    "UPPERCASE",
+    "UPPER_SNAKE_CASE",
+  ]);
+  if (!is_valid_const) {
+    this._suggestConstName(name, config, errors);
+  }
+};
+
+/**
+ * 建议常量命名
+ * @private
+ */
+Detector.prototype._suggestConstName = function (name, config, errors) {
+  if (/^[a-z][a-zA-Z0-9]*$/.test(name)) {
+    const sug_name = name.replace(/([A-Z])/g, "_$1").toUpperCase();
+    errors.push(
+      `${config.name}（常量）必须使用大写命名风格，建议改为：${sug_name}`,
+    );
+  } else if (/^[a-z][a-z0-9_]*$/.test(name)) {
+    const sug_name = name.toUpperCase();
+    errors.push(
+      `${config.name}（常量）必须使用大写命名风格，建议改为：${sug_name}`,
+    );
+  } else {
+    errors.push(
+      `${config.name}（常量）必须使用大写命名风格（如API或API_BASE_URL）`,
+    );
+  }
+};
+
+/**
+ * 检查值属性
+ * @private
+ */
+Detector.prototype._checkValueProp = function (name, config, errors) {
+  const is_upper_snake = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)+$/.test(name);
+  const is_upper_multi = /^[A-Z][A-Z0-9]*[A-Z][A-Z0-9]*$/.test(name);
+
+  if (is_upper_snake || is_upper_multi) {
+    errors.push(
+      `${config.name}（值）禁止使用大写蛇形命名（如PRODUCT_ID或PRODUCTID）`,
+    );
+  }
+
+  if (config.styles && config.styles.length > 0) {
+    const is_valid_style = this._checkStyle(name, config.styles);
+    if (!is_valid_style && !is_upper_snake && !is_upper_multi) {
+      this._suggestValueName(name, config, errors);
+    }
+  }
+};
+
+/**
+ * 建议值属性命名
+ * @private
+ */
+Detector.prototype._suggestValueName = function (name, config, errors) {
+  if (/^[A-Z][a-zA-Z0-9]*$/.test(name)) {
+    const sug_name = name
+      .replace(/([A-Z])/g, "_$1")
+      .toLowerCase()
+      .replace(/^_/, "");
+    errors.push(
+      `${config.name}（值）必须使用小写命名风格，建议改为：${sug_name}`,
+    );
+  } else if (/^[a-z][a-zA-Z0-9]*$/.test(name)) {
+    const sug_name = name.replace(/([A-Z])/g, "_$1").toLowerCase();
+    errors.push(
+      `${config.name}（值）必须使用小写命名风格，建议改为：${sug_name}`,
+    );
+  } else {
+    const allowed_styles = config.styles.join("、");
+    errors.push(
+      `${config.name}（值）必须符合以下命名风格之一：${allowed_styles}`,
+    );
+  }
+};
+
+/**
+ * 弱验证模式值检查
+ * @private
+ */
+Detector.prototype._checkWeakValue = function (name, config, errors) {
+  const is_valid_var = this._checkStyle(name, ["lowercase", "snake_case"]);
+  const is_valid_const = this._checkStyle(name, [
+    "UPPERCASE",
+    "UPPER_SNAKE_CASE",
+  ]);
+
+  if (!is_valid_var && !is_valid_const) {
+    errors.push(
+      `${config.name}（值）必须符合变量名（小写蛇形）或常量名（大写蛇形）规则`,
+    );
+  }
+};
+
+/**
+ * 检查属性名是否优先使用单个单词
+ * @private
+ */
+Detector.prototype._checkPropSingleWord = function (name, config, warnings) {
+  if (!config.single_word) return;
+
+  const has_uppercase = /[A-Z]/.test(name.slice(1));
+  const has_separators = name.includes("_") || name.includes("-");
+
+  if (has_uppercase || has_separators) {
+    warnings.push(`${config.name}应优先使用单个单词`);
+  }
+};
+
+/**
+ * 获取属性值类型
+ * @param {Object} val_node - 属性值AST节点
+ * @returns {string} 属性值类型（'function', 'class', 'value'）
+ * @private
+ */
+Detector.prototype._getPropType = function (val_node, prop_name) {
+  if (!val_node) {
+    return "value"; // 默认值类型
+  }
+
+  // 检查是否为函数
+  if (
+    val_node.type === "FunctionExpression" ||
+    val_node.type === "ArrowFunctionExpression" ||
+    (val_node.type === "Identifier" &&
+      val_node.name &&
+      (val_node.name.endsWith("Function") ||
+        val_node.name.endsWith("Func") ||
+        val_node.name.startsWith("on") ||
+        val_node.name.startsWith("handle")))
+  ) {
+    return "function";
+  }
+
+  // 检查是否为类
+  if (
+    val_node.type === "ClassExpression" ||
+    (val_node.type === "Identifier" &&
+      val_node.name &&
+      /^[A-Z][a-zA-Z]*$/.test(val_node.name))
+  ) {
+    return "class";
+  }
+
+  // 检查是否为常量/配置值（应该使用UPPERCASE风格）
+  if (this._isConst(val_node, prop_name)) {
+    return "constant";
+  }
+
+  // 默认为值类型
+  return "value";
+};
+
+/**
+ * 检查是否为常量值（应该使用UPPERCASE风格命名）
+ * @param {Object} val_node - 属性值AST节点
+ * @param {string} prop_name - 属性名（可选，用于更智能的判断）
+ * @returns {boolean} 是否为常量值
+ * @private
+ */
+Detector.prototype._isConst = function (val_node, prop_name) {
+  if (!val_node) {
+    return false;
+  }
+
+  const is_prim_const = this._isPrimConst(val_node);
+  const is_cfg_obj = this._isCfgObj(val_node);
+  const is_const_id = this._isConstId(val_node);
+
+  if (prop_name) {
+    return this._isConstWithName(
+      val_node,
+      prop_name,
+      is_prim_const,
+      is_cfg_obj,
+      is_const_id,
+    );
+  }
+
+  return this._isConstWithoutName(is_prim_const, is_cfg_obj, is_const_id);
+};
+
+/**
+ * 检查是否为基本类型常量
+ * @private
+ */
+Detector.prototype._isPrimConst = function (val_node) {
+  return (
+    val_node.type === "Literal" &&
+    (typeof val_node.value === "string" ||
+      typeof val_node.value === "number" ||
+      typeof val_node.value === "boolean")
+  );
+};
+
+/**
+ * 检查是否为配置对象
+ * @private
+ */
+Detector.prototype._isCfgObj = function (val_node) {
+  return (
+    val_node.type === "ObjectExpression" &&
+    val_node.properties &&
+    val_node.properties.length > 0 &&
+    val_node.properties.every(
+      (prop) =>
+        prop.value &&
+        (prop.value.type === "Literal" ||
+          (prop.value.type === "Identifier" &&
+            /^[A-Z_][A-Z0-9_]*$/.test(prop.value.name))),
+    )
+  );
+};
+
+/**
+ * 检查是否为常量标识符
+ * @private
+ */
+Detector.prototype._isConstId = function (val_node) {
+  return (
+    val_node.type === "Identifier" && /^[A-Z_][A-Z0-9_]*$/.test(val_node.name)
+  );
+};
+
+/**
+ * 有属性名时的常量判断
+ * @private
+ */
+Detector.prototype._isConstWithName = function (
+  val_node,
+  prop_name,
+  is_prim_const,
+  is_cfg_obj,
+  is_const_id,
+) {
+  const is_upper_name = /^[A-Z_][A-Z0-9_]*$/.test(prop_name);
+  const is_inst_data_name =
+    /^[a-z][a-z0-9_]*$/.test(prop_name) ||
+    /^[a-z][a-zA-Z0-9]*$/.test(prop_name);
+  const is_val_const = this._isValConst(val_node, prop_name);
+
+  if (is_inst_data_name && is_prim_const) {
+    return is_val_const ? true : false;
+  }
+
+  if (is_upper_name && (is_prim_const || is_cfg_obj)) {
+    return true;
+  }
+
+  return is_cfg_obj || is_const_id;
+};
+
+/**
+ * 无属性名时的常量判断
+ * @private
+ */
+Detector.prototype._isConstWithoutName = function (
+  is_prim_const,
+  is_cfg_obj,
+  is_const_id,
+) {
+  if (is_cfg_obj || is_const_id) {
+    return true;
+  }
+  return is_prim_const;
+};
+
+/**
+ * 通过值内容分析判断是否为常量
+ * @param {Object} val_node - 属性值AST节点
+ * @param {string} prop_name - 属性名
+ * @returns {boolean} 值内容是否为常量特征
+ * @private
+ */
+Detector.prototype._isValConst = function (val_node, prop_name) {
+  if (!val_node || val_node.type !== "Literal") {
+    return false;
+  }
+
+  const value = val_node.value;
+
+  switch (typeof value) {
+    case "string":
+      return this._isStringConst(value, prop_name);
+    case "number":
+      return this._isNumberConst(value, prop_name);
+    case "boolean":
+      return this._isBooleanConst(value, prop_name);
+    default:
+      return this._isConstSem(prop_name, value);
+  }
+};
+
+/**
+ * 检查字符串值是否为常量
+ * @private
+ */
+Detector.prototype._isStringConst = function (value, prop_name) {
+  const is_url_const = this._isUrlConst(value, prop_name);
+  if (is_url_const) return true;
+
+  const is_config_const = this._isConfigConst(value, prop_name);
+  if (is_config_const) return true;
+
+  return false;
+};
+
+/**
+ * 检查URL相关的字符串常量
+ * @private
+ */
+Detector.prototype._isUrlConst = function (value, prop_name) {
+  const is_url_related_name =
+    /(url|uri|endpoint|api|base|host|domain|path)$/i.test(prop_name);
+  const is_url_value =
+    /^(https?:\/\/|\/\/|www\.|ftp:\/\/)/.test(value) ||
+    /\.[a-z]{2,6}(\/|$)/.test(value);
+
+  return is_url_related_name && is_url_value;
+};
+
+/**
+ * 检查配置相关的字符串常量
+ * @private
+ */
+Detector.prototype._isConfigConst = function (value, prop_name) {
+  const is_config_related_name =
+    /(config|setting|option|default|mode|env|version)$/i.test(prop_name);
+  const is_config_value =
+    /^(v?\d+\.\d+|true|false|null|undefined|production|development|test)$/i.test(
+      value,
+    );
+
+  return is_config_related_name && is_config_value;
+};
+
+/**
+ * 检查数字值是否为常量
+ * @private
+ */
+Detector.prototype._isNumberConst = function (value, prop_name) {
+  const is_config_num = this._isConfigNumber(value, prop_name);
+  if (is_config_num) return true;
+
+  const is_common_const = this._isCommonNumber(value);
+  if (is_common_const) return true;
+
+  return false;
+};
+
+/**
+ * 检查配置相关的数字常量
+ * @private
+ */
+Detector.prototype._isConfigNumber = function (value, prop_name) {
+  const is_config_number_name =
+    /(timeout|delay|interval|retry|count|limit|max|min|size|length|port)$/i.test(
+      prop_name,
+    );
+  return is_config_number_name;
+};
+
+/**
+ * 检查常见数字常量
+ * @private
+ */
+Detector.prototype._isCommonNumber = function (value) {
+  const common_constants = [
+    0, 1, 10, 100, 1000, 60, 3600, 86400, 1024, 2048, 4096, 8192,
+  ];
+  return common_constants.includes(value);
+};
+
+/**
+ * 检查布尔值是否为常量
+ * @private
+ */
+Detector.prototype._isBooleanConst = function (value, prop_name) {
+  const is_config_bool = this._isConfigBoolean(prop_name);
+  const is_inst_state = this._isInstanceState(prop_name);
+
+  if (is_config_bool && !is_inst_state) {
+    return true;
+  }
+
+  if (is_inst_state) {
+    return false;
+  }
+
+  return false;
+};
+
+/**
+ * 检查配置相关的布尔值
+ * @private
+ */
+Detector.prototype._isConfigBoolean = function (prop_name) {
+  return /^(is_)?(enabled|disabled|debug|verbose|strict|lazy|secure|ssl|tls|compressed|cached)$/i.test(
+    prop_name,
+  );
+};
+
+/**
+ * 检查实例数据状态的布尔值
+ * @private
+ */
+Detector.prototype._isInstanceState = function (prop_name) {
+  return /^(is_)?(active|inactive|visible|hidden|required|optional|valid|invalid|available|busy|online|offline|open|closed|locked|unlocked)$/i.test(
+    prop_name,
+  );
+};
+
+/**
+ * 通过属性名语义分析判断是否为常量
+ * @param {string} prop_name - 属性名
+ * @param {any} value - 属性值
+ * @returns {boolean} 根据语义分析是否为常量
+ * @private
+ */
+Detector.prototype._isConstSem = function (prop_name, value) {
+  // 精确匹配常量相关词汇（使用单词边界匹配）
+  const const_keys = [
+    "api",
+    "base",
+    "url",
+    "uri",
+    "endpoint",
+    "host",
+    "domain",
+    "timeout",
+    "delay",
+    "interval",
+    "retry",
+    "count",
+    "limit",
+    "max",
+    "min",
+    "size",
+    "length",
+    "port",
+    "version",
+    "config",
+    "setting",
+    "option",
+    "default",
+    "mode",
+    "env",
+    "debug",
+    "verbose",
+    "strict",
+    "lazy",
+    "secure",
+    "ssl",
+    "tls",
+    "compressed",
+    "cached",
+  ];
+
+  // 使用单词边界匹配，避免误匹配（如"active"匹配"is_active"）
+  const has_const_key = const_keys.some((keyword) => {
+    const regex = new RegExp(`\\b${keyword}\\b`, "i");
+    return regex.test(prop_name);
+  });
+
+  if (has_const_key) {
+    // 如果属性名包含常量相关词汇，且值是基本类型，更可能是常量
+    return (
+      typeof value === "string" ||
+      typeof value === "number" ||
+      typeof value === "boolean"
+    );
+  }
+
+  // 实例数据相关词汇（更精确的匹配）
+  const inst_keys = [
+    "user",
+    "person",
+    "customer",
+    "member",
+    "client",
+    "product",
+    "item",
+    "goods",
+    "article",
+    "order",
+    "cart",
+    "payment",
+    "invoice",
+    "name",
+    "age",
+    "email",
+    "phone",
+    "address",
+    "title",
+    "description",
+    "content",
+    "message",
+    "active",
+    "inactive",
+    "visible",
+    "hidden",
+    "required",
+    "optional",
+    "valid",
+    "invalid",
+    "available",
+    "busy",
+    "online",
+    "offline",
+    "open",
+    "closed",
+    "locked",
+    "unlocked",
+  ];
+
+  // 使用单词边界匹配
+  const has_inst_key = inst_keys.some((keyword) => {
+    const regex = new RegExp(`\\b${keyword}\\b`, "i");
+    return regex.test(prop_name);
+  });
+
+  if (has_inst_key) {
+    // 如果属性名包含实例数据相关词汇，更可能是实例数据
+    return false;
+  }
+
+  // 属性名模式分析
+  const is_likely_const_pat = this._isConstPat(prop_name, value);
+
+  return is_likely_const_pat;
+};
+
+/**
+ * 通过属性名模式分析判断是否为常量
+ * @param {string} prop_name - 属性名
+ * @param {any} value - 属性值
+ * @returns {boolean} 根据模式分析是否为常量
+ * @private
+ */
+Detector.prototype._isConstPat = function (prop_name, value) {
+  // UPPERCASE模式：全大写或大写蛇形
+  const is_uppercase_pattern = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/.test(prop_name);
+
+  // 配置前缀模式：包含config、setting、default等前缀
+  const has_config_prefix = /^(config|setting|option|default|env|mode)_/i.test(
+    prop_name,
+  );
+
+  // 常量后缀模式：包含url、timeout、count等后缀
+  const has_constant_suffix =
+    /_(url|uri|endpoint|api|base|host|domain|timeout|delay|interval|retry|count|limit|max|min|size|length|port|version)$/i.test(
+      prop_name,
+    );
+
+  // 实例数据模式：包含user、product、order等前缀或后缀
+  const has_instance_pattern =
+    /^(user|person|customer|member|client|product|item|goods|article|order|cart|payment|invoice)_/i.test(
+      prop_name,
+    ) ||
+    /_(user|person|customer|member|client|product|item|goods|article|order|cart|payment|invoice)$/i.test(
+      prop_name,
+    );
+
+  // 状态模式：以is_开头或包含状态相关词汇
+  const is_status_pattern =
+    /^is_/i.test(prop_name) ||
+    /_(active|inactive|visible|hidden|required|optional|valid|invalid|available|busy|online|offline|open|closed|locked|unlocked)$/i.test(
+      prop_name,
+    );
+
+  // 判断逻辑
+  if (is_uppercase_pattern || has_config_prefix || has_constant_suffix) {
+    return true; // 常量模式
+  }
+
+  if (has_instance_pattern || is_status_pattern) {
+    return false; // 实例数据模式
+  }
+
+  return false;
+};
+
+/**
+ * 检查是否包含禁止的废话词
+ * @param {string} name - 名称
+ * @returns {boolean} 是否包含禁止词
+ * @private
+ */
+Detector.prototype._hasBadWord = function (name) {
+  if (!name) {
+    return false;
+  }
+
+  const forbidden_words = this.config.forbidden_words || [];
+
+  return forbidden_words.some((word) =>
+    name.toLowerCase().includes(word.toLowerCase()),
+  );
+};
+
+/**
+ * 检测名称是否符合规范
+ * @param {string} name - 名称
+ * @param {string} type - 类型（class/function/variable/constant/private）
+ * @returns {Object} 检测结果
+ */
+Detector.prototype.checkName = function (name, type) {
+  if (typeof name !== "string" || !name.trim()) {
+    return {
+      valid: false,
+      errors: ["名称必须是有效的字符串"],
+    };
+  }
+
+  if (typeof type !== "string" || !type.trim()) {
+    return {
+      valid: false,
+      errors: ["类型必须是有效的字符串"],
+    };
+  }
+
+  const rule_method = this._rules[type];
+  if (!rule_method) {
+    return {
+      valid: false,
+      errors: [`不支持的类型: ${type}`],
+    };
+  }
+
+  try {
+    return rule_method(name);
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [`检测名称时出错: ${error.message}`],
+    };
+  }
+};
+
+/**
+ * 批量检测名称
+ * @param {Array} names - 名称数组
+ * @param {string} type - 类型
+ * @returns {Array} 检测结果数组
+ */
+Detector.prototype.checkNames = function (names, type) {
+  if (!Array.isArray(names)) {
+    throw new TypeError("名称必须是数组");
+  }
+
+  return names.map((name) => this.check_name(name, type));
+};
+
+/**
+ * ESLint规则实现
+ */
+
+/**
+ * 类名大驼峰规则
+ */
+const class_name_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "类名必须使用大驼峰命名法（PascalCase）且优先使用单个单词",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      ClassDeclaration(node) {
+        const class_name = node.id.name;
+        const detector = new Detector({ "class-name": options });
+        const result = detector.checkName(class_name, "class-name");
+
+        if (!result.valid) {
+          result.errors.forEach((error) => {
+            context.report({
+              node: node.id,
+              message: `类名"${class_name}"不符合规范: ${error}`,
+            });
+          });
+        }
+      },
+    };
+  },
+};
+
+/**
+ * 函数名小驼峰规则
+ */
+const function_name_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "函数名必须使用小驼峰命名法（camelCase）且优先使用单个单词",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      FunctionDeclaration(node) {
+        const function_name = node.id ? node.id.name : "anonymous";
+        if (function_name !== "anonymous") {
+          const detector = new Detector({ "function-name": options });
+          const result = detector.checkName(function_name, "function-name");
+
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: node.id,
+                message: `函数名"${function_name}"不符合规范: ${error}`,
+              });
+            });
+          }
+        }
+      },
+
+      FunctionExpression(node) {
+        if (node.id) {
+          const function_name = node.id.name;
+          const detector = new Detector({ "function-name": options });
+          const result = detector.checkName(function_name, "function-name");
+
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: node.id,
+                message: `函数表达式名"${function_name}"不符合规范: ${error}`,
+              });
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+/**
+ * 方法名小驼峰规则
+ */
+const method_name_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "方法名必须使用小驼峰命名法（camelCase）且优先使用单个单词",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      MethodDefinition(node) {
+        const method_name = node.key.name;
+
+        // 跳过私有方法的检测（私有方法由private-naming规则处理）
+        if (method_name.startsWith("_")) {
+          return;
+        }
+
+        // 跳过JavaScript内置特殊方法名
+        const builtin_methods = [
+          "constructor",
+          "toString",
+          "valueOf",
+          "toJSON",
+        ];
+        if (builtin_methods.includes(method_name)) {
+          return;
+        }
+
+        const detector = new Detector({ "method-name": options });
+        const result = detector.checkName(method_name, "method-name");
+
+        if (!result.valid) {
+          result.errors.forEach((error) => {
+            context.report({
+              node: node.key,
+              message: `方法名"${method_name}"不符合规范: ${error}`,
+            });
+          });
+        }
+      },
+    };
+  },
+};
+
+/**
+ * 变量名小写蛇形规则
+ */
+const variable_name_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "变量名必须使用小写蛇形命名法（snake_case）",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+
+    function isRealConstant(node) {
+      // 真正的常量特征：
+      // 1. 在模块顶层作用域（不在函数或块内）
+      // 2. 名称包含大写字母（表示意图作为常量）
+
+      // 检查是否在模块顶层
+      let scope_node = node;
+      while (scope_node.parent) {
+        scope_node = scope_node.parent;
+        if (
+          scope_node.type === "FunctionDeclaration" ||
+          scope_node.type === "FunctionExpression" ||
+          scope_node.type === "ArrowFunctionExpression" ||
+          scope_node.type === "BlockStatement"
+        ) {
+          return false; // 在函数或块内，不是真正的常量
+        }
+      }
+
+      // 检查名称是否包含大写字母（表示意图作为常量）
+      const name = node.id.name;
+      return /[A-Z]/.test(name);
+    }
+
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier") {
+          // 对于const声明，只对不是真正常量的应用变量命名规则
+          if (node.parent.kind === "const" && isRealConstant(node)) {
+            return; // 这是真正的常量，由常量规则处理
+          }
+
+          const variable_name = node.id.name;
+          const detector = new Detector({ "variable-name": options });
+          const result = detector.checkName(variable_name, "variable-name");
+
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: node.id,
+                message: `变量名"${variable_name}"不符合规范: ${error}`,
+              });
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+/**
+ * 常量名大写蛇形规则
+ */
+const constant_name_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "常量名必须使用大写蛇形命名法（UPPER_SNAKE_CASE）",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+
+    function isRealConstant(node) {
+      // 真正的常量特征：
+      // 1. 在模块顶层作用域（不在函数或块内）
+      // 2. 名称包含大写字母（表示意图作为常量）
+      // 3. 或者名称是常见的常量模式（如全大写）
+
+      // 检查是否在模块顶层
+      let scope_node = node;
+      while (scope_node.parent) {
+        scope_node = scope_node.parent;
+        if (
+          scope_node.type === "FunctionDeclaration" ||
+          scope_node.type === "FunctionExpression" ||
+          scope_node.type === "ArrowFunctionExpression" ||
+          scope_node.type === "BlockStatement"
+        ) {
+          return false; // 在函数或块内，不是真正的常量
+        }
+      }
+
+      // 检查名称是否包含大写字母（表示意图作为常量）
+      const name = node.id.name;
+      return /[A-Z]/.test(name);
+    }
+
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier" && node.parent.kind === "const") {
+          // 只对真正的常量应用常量命名规则
+          if (isRealConstant(node)) {
+            const constant_name = node.id.name;
+            const detector = new Detector({ "constant-name": options });
+            const result = detector.checkName(constant_name, "constant-name");
+
+            if (!result.valid) {
+              result.errors.forEach((error) => {
+                context.report({
+                  node: node.id,
+                  message: `常量名"${constant_name}"不符合规范: ${error}`,
+                });
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};
+
+/**
+ * 入参名小写蛇形规则
+ */
+const param_name_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "入参名必须使用小写蛇形命名法（snake_case）",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+
+    function checkParam(node) {
+      // 处理不同节点类型的参数
+      let params = [];
+
+      if (node.type === "MethodDefinition") {
+        // MethodDefinition节点（包括构造函数）的参数在node.value.params中
+        params = node.value ? node.value.params || [] : [];
+      } else {
+        // 其他函数节点的参数在node.params中
+        params = node.params || [];
+      }
+
+      params.forEach((param) => {
+        if (param.type === "Identifier") {
+          const param_name = param.name;
+          const detector = new Detector({ "param-name": options });
+          const result = detector.checkName(param_name, "param-name");
+
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: param,
+                message: `入参名"${param_name}"不符合规范: ${error}`,
+              });
+            });
+          }
+        }
+      });
+    }
+
+    return {
+      FunctionDeclaration: checkParam,
+      FunctionExpression: checkParam,
+      ArrowFunctionExpression: checkParam,
+      MethodDefinition: checkParam,
+    };
+  },
+};
+
+/**
+ * 属性名小写蛇形规则
+ */
+const prop_name_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "属性名必须使用小写蛇形命名法（snake_case）",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      Property(node) {
+        // 检测类属性、对象字面量属性、模块导出属性
+        const is_class_property =
+          node.parent &&
+          (node.parent.type === "ClassBody" ||
+            (node.parent.type === "ObjectExpression" &&
+              node.parent.parent &&
+              node.parent.parent.type === "ClassDeclaration"));
+
+        const is_object_property =
+          node.parent && node.parent.type === "ObjectExpression";
+
+        // 检测所有非私有属性（不以_开头）
+        if (node.key.type === "Identifier" && !node.key.name.startsWith("_")) {
+          const prop_name = node.key.name;
+          const detector = new Detector({ "property-name": options });
+          const result = detector._checkPropName(prop_name, node.value);
+
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: node.key,
+                message: `属性名"${prop_name}"不符合规范: ${error}`,
+              });
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+/**
+ * 私有方法命名规则
+ */
+const private_method_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "私有方法必须以单下划线开头，后跟小驼峰命名或小写单词",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      MethodDefinition(node) {
+        const method_name = node.key.name;
+        if (method_name.startsWith("_")) {
+          const detector = new Detector({ "private-method-naming": options });
+          const result = detector.checkName(
+            method_name,
+            "private-method-naming",
+          );
+
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: node.key,
+                message: `私有方法名"${method_name}"不符合规范: ${error}`,
+              });
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+/**
+ * 私有变量命名规则
+ */
+const private_variable_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "私有变量必须以单下划线开头，后跟小写蛇形命名或小写单词",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      Property(node) {
+        if (node.key.type === "Identifier" && node.key.name.startsWith("_")) {
+          const private_name = node.key.name;
+          const detector = new Detector({ "private-variable-naming": options });
+          const result = detector.checkName(
+            private_name,
+            "private-variable-naming",
+          );
+
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: node.key,
+                message: `私有属性名"${private_name}"不符合规范: ${error}`,
+              });
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+/**
+ * 实例属性赋值命名规则（检测 this.property = value 模式）
+ */
+const instance_property_rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "实例属性赋值必须符合命名规范",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          regex: { type: "string" },
+          min: { type: "number" },
+          max: { type: "number" },
+          message: { type: "string" },
+          single_word: { type: "boolean" },
+          single_word_len: { type: "number" },
+          styles: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    return {
+      AssignmentExpression(node) {
+        // 检测 this.property = value 模式
+        if (
+          node.left.type === "MemberExpression" &&
+          node.left.object.type === "ThisExpression" &&
+          node.left.property.type === "Identifier" &&
+          !node.left.property.name.startsWith("_")
+        ) {
+          const prop_name = node.left.property.name;
+          const detector = new Detector({ "property-name": options });
+          const result = detector._checkPropName(prop_name, node.right);
+
+          if (!result.valid) {
+            result.errors.forEach((error) => {
+              context.report({
+                node: node.left.property,
+                message: `实例属性名"${prop_name}"不符合规范: ${error}`,
+              });
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+/**
+ * 命名规范ESLint插件
+ */
+const naming_rules = {
+  "class-name": class_name_rule,
+  "function-name": function_name_rule,
+  "method-name": method_name_rule,
+  "variable-name": variable_name_rule,
+  "constant-name": constant_name_rule,
+  "private-method-naming": private_method_rule,
+  "private-variable-naming": private_variable_rule,
+  "param-name": param_name_rule,
+  "property-name": prop_name_rule,
+  "instance-property": instance_property_rule,
+};
+
+module.exports = {
+  Detector,
+  rules: naming_rules,
+};