akfun 5.1.13 → 5.1.15

package/module/main.js

@@ -12,11 +12,18 @@ const getCurWebpackConfig = require('../src/utils/getCurWebpackConfig.js'); //
 const aliBOS = require('../src/oss/aliBos.js');
 const baiduBOS = require('../src/oss/baiduBos.js');
 
+// 新增：配置管理和环境管理
+const configManager = require('../src/config/ConfigManager');
+const { validateConfig } = require('../src/utils/configValidator');
+
 module.exports = {
+  // 核心功能
   dev: devAction,
   build: buildAction,
   build2esm,
   inspect,
+  
+  // 工具方法
   gitClone,
   createFile,
   resolve,
@@ -24,6 +31,12 @@ module.exports = {
   deepMergeConfig,
   getCurWebpackConfig,
   curWebpackBaseConfPath: getCurWebpackConfig('base'),
+  
+  // OSS 上传
   aliBOS,
-  baiduBOS
+  baiduBOS,
+  
+  // 新增：配置管理
+  configManager,
+  validateConfig
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akfun",
-  "version": "5.1.13",
+  "version": "5.1.15",
   "description": "前端脚手架：支持Vue技术栈和react技术栈",
   "keywords": [
     "前端工程",

package/src/config/index.js

@@ -1,15 +1,19 @@
-// 统一路径解析：
-const { resolve } = require('../utils/pathUtils');
-const defaultAKFunConfig = require('./default.config');
-const getConfigObj = require('../utils/getConfigObj');
-const deepMergeConfig = require('../utils/deepMergeConfig');
-
-/** akfun脚手架赋予当前项目的默认配置
- * 备注：项目根目录的akfun.config.js的配置内容优先级高于defultAKFunConfig
+/**
+ * 配置入口文件
+ * 统一加载和管理 AKFun 配置
  */
 
-// 从项目根目录获取当前项目的配置文件
-const curProjectConfig = getConfigObj(resolve('akfun.config.js'));
+// 使用新的配置管理器
+const configManager = require('../manage/ConfigManager');
 
-// 备注：数组类型则直接覆盖
-module.exports = deepMergeConfig(defaultAKFunConfig, curProjectConfig);
+// 自动加载用户配置文件
+configManager.autoLoadConfig();
+
+// 合并配置
+const mergedConfig = configManager.mergeConfig();
+
+// 导出合并后的配置（向后兼容）
+module.exports = mergedConfig;
+
+// 同时导出配置管理器实例，供高级用户使用
+module.exports.configManager = configManager;

package/src/config/rollup.config.js

@@ -67,6 +67,10 @@ module.exports = function (fileName, akfunConfig) {
        */
       externals({
         include: build2esm.excludeList || []
+        // exclude: ['./**', '../**'], // 排除所有相对路径模块
+        // deps: true, // 只标记 node_modules 中的依赖
+        // devDeps: false, // 不标记 devDependencies
+        // peerDeps: true, // 标记 peerDependencies
       }),
       nodeResolve({
         extensions: curConfig.webpack.resolve.extensions
@@ -82,7 +86,11 @@ module.exports = function (fileName, akfunConfig) {
       // jsx( {factory: 'React.createElement'} ),
       buildType === 'ts' ? undefined : jsx({ factory: 'React.createElement' }),
       vue(),
-      commonjs(),
+      commonjs({
+        transformMixedEsModules: true, // 转换混合的 ES 模块和 CommonJS 模块
+        strictRequires: true, // 严格模式处理 require，确保所有 require 都被正确处理
+        ignoreDynamicRequires: true // 忽略动态 require
+      }),
       postcss({
         extensions: ['.css', '.scss', '.sass', '.styl', '.stylus', '.less'],
         // Or with custom file name, it will generate file relative to bundle.js in v3

package/src/manage/ConfigManager.js

@@ -0,0 +1,315 @@
+/**
+ * 配置管理器
+ * 负责加载、合并和验证配置
+ */
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+const deepMergeConfig = require('../utils/deepMergeConfig');
+
+class ConfigManager {
+  constructor() {
+    this.defaultConfig = require('../config/default.config');
+    this.userConfig = null;
+    this.mergedConfig = null;
+    this.configPath = null;
+  }
+
+  /**
+   * 加载用户配置文件
+   * @param {string} configPath - 配置文件路径（相对于项目根目录）
+   * @returns {Object|null} 用户配置对象，如果不存在则返回 null
+   */
+  loadUserConfig(configPath) {
+    try {
+      // 支持相对路径和绝对路径
+      const resolvedPath = path.isAbsolute(configPath)
+        ? configPath
+        : path.resolve(process.cwd(), configPath);
+
+      this.configPath = resolvedPath;
+
+      if (!fs.existsSync(resolvedPath)) {
+        console.log(chalk.yellow(`\n⚠️  未找到用户配置文件: ${configPath}\n   使用默认配置运行\n`));
+        return null;
+      }
+
+      // 清除 require 缓存，确保获取最新配置
+      delete require.cache[resolvedPath];
+      this.userConfig = require(resolvedPath);
+
+      console.log(chalk.green(`✓ 已加载配置文件: ${configPath}`));
+      return this.userConfig;
+    } catch (error) {
+      console.error(chalk.red(`\n❌ 加载配置文件失败: ${configPath}\n`));
+      console.error(chalk.red(`   错误信息: ${error.message}\n`));
+
+      if (error.stack && process.env.AKFUN_DEBUG) {
+        console.error(chalk.gray(error.stack));
+      }
+
+      console.log(chalk.yellow('   将使用默认配置继续运行\n'));
+      return null;
+    }
+  }
+
+  /**
+   * 自动查找并加载配置文件
+   * 按优先级查找：akfun.config.js -> akfun.config.json
+   * @returns {Object|null}
+   */
+  autoLoadConfig() {
+    const configFiles = ['akfun.config.js', 'akfun.config.json', '.akfunrc.js', '.akfunrc.json'];
+
+    for (const configFile of configFiles) {
+      const configPath = path.resolve(process.cwd(), configFile);
+      if (fs.existsSync(configPath)) {
+        return this.loadUserConfig(configPath);
+      }
+    }
+
+    console.log(chalk.gray('   未找到配置文件，使用默认配置'));
+    return null;
+  }
+
+  /**
+   * 合并配置
+   * @param {Object} userConfig - 用户配置（可选）
+   * @returns {Object} 合并后的配置
+   */
+  mergeConfig(userConfig) {
+    const configToMerge = userConfig || this.userConfig || {};
+
+    try {
+      this.mergedConfig = deepMergeConfig(this.defaultConfig, configToMerge);
+
+      // 输出配置摘要
+      if (process.env.AKFUN_DEBUG) {
+        this.printConfigSummary();
+      }
+
+      return this.mergedConfig;
+    } catch (error) {
+      console.error(chalk.red('\n❌ 配置合并失败:'));
+      console.error(chalk.red(`   ${error.message}\n`));
+      throw error;
+    }
+  }
+
+  /**
+   * 获取配置
+   * @param {string} key - 配置键路径（支持点号分隔，如 'webpack.resolve.alias'）
+   * @returns {any} 配置值
+   */
+  getConfig(key) {
+    if (!this.mergedConfig) {
+      this.mergeConfig();
+    }
+
+    if (!key) {
+      return this.mergedConfig;
+    }
+
+    // 支持点号分隔的键路径
+    const keys = key.split('.');
+    let result = this.mergedConfig;
+
+    for (const k of keys) {
+      if (result && typeof result === 'object' && k in result) {
+        result = result[k];
+      } else {
+        return undefined;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 设置配置值（仅在内存中）
+   * @param {string} key - 配置键路径
+   * @param {any} value - 配置值
+   */
+  setConfig(key, value) {
+    if (!this.mergedConfig) {
+      this.mergeConfig();
+    }
+
+    const keys = key.split('.');
+    let target = this.mergedConfig;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const k = keys[i];
+      if (!(k in target) || typeof target[k] !== 'object') {
+        target[k] = {};
+      }
+      target = target[k];
+    }
+
+    target[keys[keys.length - 1]] = value;
+  }
+
+  /**
+   * 验证配置
+   * @returns {Object} 验证后的配置
+   */
+  validateConfig() {
+    if (!this.mergedConfig) {
+      this.mergeConfig();
+    }
+
+    try {
+      // 基础验证
+      this._validateBasicConfig();
+
+      // 如果有配置验证器，使用它
+      try {
+        const { validateConfig } = require('../utils/configValidator');
+        return validateConfig(this.mergedConfig);
+      } catch (error) {
+        // 如果配置验证器不存在或出错，只进行基础验证
+        if (process.env.AKFUN_DEBUG) {
+          console.log(chalk.gray('   使用基础配置验证'));
+        }
+      }
+
+      return this.mergedConfig;
+    } catch (error) {
+      console.error(chalk.red('\n❌ 配置验证失败:'));
+      console.error(chalk.red(`   ${error.message}\n`));
+      throw error;
+    }
+  }
+
+  /**
+   * 基础配置验证
+   * @private
+   */
+  _validateBasicConfig() {
+    const config = this.mergedConfig;
+
+    // 验证必需的配置项
+    if (!config.dev || typeof config.dev !== 'object') {
+      throw new Error('dev 配置缺失或格式错误');
+    }
+
+    if (!config.build || typeof config.build !== 'object') {
+      throw new Error('build 配置缺失或格式错误');
+    }
+
+    if (!config.webpack || typeof config.webpack !== 'object') {
+      throw new Error('webpack 配置缺失或格式错误');
+    }
+
+    // 验证端口号
+    if (config.dev.port) {
+      const port = parseInt(config.dev.port, 10);
+      if (isNaN(port) || port < 1 || port > 65535) {
+        throw new Error('dev.port 必须是 1-65535 之间的数字');
+      }
+    }
+
+    // 验证路径
+    if (config.build.assetsRoot) {
+      const assetsRoot = config.build.assetsRoot;
+      if (typeof assetsRoot !== 'string') {
+        throw new Error('build.assetsRoot 必须是字符串类型的路径');
+      }
+    }
+  }
+
+  /**
+   * 打印配置摘要
+   * @private
+   */
+  printConfigSummary() {
+    console.log(chalk.cyan('\n📋 配置摘要:'));
+
+    const config = this.mergedConfig;
+
+    if (config.dev) {
+      console.log(chalk.gray('   开发环境:'));
+      console.log(chalk.gray(`     - 端口: ${config.dev.port}`));
+      console.log(chalk.gray(`     - 自动打开浏览器: ${config.dev.autoOpenBrowser}`));
+      console.log(
+        chalk.gray(`     - 代理配置: ${Object.keys(config.dev.proxyTable || {}).length} 个`)
+      );
+    }
+
+    if (config.build) {
+      console.log(chalk.gray('   生产构建:'));
+      console.log(chalk.gray(`     - 输出目录: ${config.build.assetsRoot}`));
+      console.log(chalk.gray(`     - SourceMap: ${config.build.productionSourceMap}`));
+      console.log(chalk.gray(`     - Gzip 压缩: ${config.build.productionGzip}`));
+    }
+
+    if (config.webpack && config.webpack.resolve) {
+      console.log(chalk.gray('   Webpack 配置:'));
+      console.log(chalk.gray(`     - 解析扩展名: ${config.webpack.resolve.extensions.length} 个`));
+      console.log(
+        chalk.gray(`     - 别名配置: ${Object.keys(config.webpack.resolve.alias || {}).length} 个`)
+      );
+    }
+
+    if (config.settings) {
+      console.log(chalk.gray('   代码检查:'));
+      console.log(chalk.gray(`     - ESLint: ${config.settings.enableESLint}`));
+      console.log(chalk.gray(`     - StyleLint: ${config.settings.enableStyleLint}`));
+    }
+
+    console.log('');
+  }
+
+  /**
+   * 重置配置管理器
+   */
+  reset() {
+    this.userConfig = null;
+    this.mergedConfig = null;
+    this.configPath = null;
+  }
+
+  /**
+   * 获取默认配置
+   * @returns {Object}
+   */
+  getDefaultConfig() {
+    return this.defaultConfig;
+  }
+
+  /**
+   * 获取用户配置
+   * @returns {Object|null}
+   */
+  getUserConfig() {
+    return this.userConfig;
+  }
+
+  /**
+   * 导出配置到文件（用于调试）
+   * @param {string} outputPath - 输出路径
+   */
+  exportConfig(outputPath) {
+    if (!this.mergedConfig) {
+      this.mergeConfig();
+    }
+
+    const fs = require('fs');
+    const output = JSON.stringify(this.mergedConfig, null, 2);
+
+    try {
+      fs.writeFileSync(outputPath, output, 'utf-8');
+      console.log(chalk.green(`✓ 配置已导出到: ${outputPath}`));
+    } catch (error) {
+      console.error(chalk.red(`❌ 配置导出失败: ${error.message}`));
+    }
+  }
+}
+
+// 导出单例实例
+const configManager = new ConfigManager();
+
+// 也导出类，方便测试
+configManager.ConfigManager = ConfigManager;
+
+module.exports = configManager;

package/src/utils/configValidator.js

@@ -0,0 +1,440 @@
+/**
+ * 配置验证器
+ * 提供配置项的验证功能
+ */
+const chalk = require('chalk');
+const path = require('path');
+
+class ConfigValidator {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+  }
+
+  /**
+   * 验证配置对象
+   * @param {Object} config - 配置对象
+   * @returns {Object} 验证后的配置
+   */
+  validate(config) {
+    this.errors = [];
+    this.warnings = [];
+
+    if (!config || typeof config !== 'object') {
+      throw new Error('配置必须是一个对象');
+    }
+
+    // 验证各个部分
+    this._validateSettings(config.settings);
+    this._validateWebpack(config.webpack);
+    this._validateDev(config.dev);
+    this._validateBuild(config.build);
+    this._validateBuild2Lib(config.build2lib);
+    this._validateBuild2Esm(config.build2esm);
+    this._validateEnvParams(config.envParams);
+
+    // 输出警告
+    if (this.warnings.length > 0) {
+      console.log(chalk.yellow('\n⚠️  配置警告:'));
+      this.warnings.forEach((warning) => {
+        console.log(chalk.yellow(`   - ${warning}`));
+      });
+      console.log('');
+    }
+
+    // 如果有错误，抛出异常
+    if (this.errors.length > 0) {
+      console.error(chalk.red('\n❌ 配置验证失败:'));
+      this.errors.forEach((error) => {
+        console.error(chalk.red(`   - ${error}`));
+      });
+      console.log('');
+      throw new Error('配置验证失败，请检查以上错误信息');
+    }
+
+    return config;
+  }
+
+  /**
+   * 验证 settings 配置
+   * @private
+   */
+  _validateSettings(settings) {
+    if (!settings) return;
+
+    const booleanFields = [
+      'enableESLint',
+      'enableESLintFix',
+      'enableStyleLint',
+      'enableStyleLintFix'
+    ];
+
+    booleanFields.forEach((field) => {
+      if (settings[field] !== undefined && typeof settings[field] !== 'boolean') {
+        this.errors.push(`settings.${field} 必须是布尔值`);
+      }
+    });
+  }
+
+  /**
+   * 验证 webpack 配置
+   * @private
+   */
+  _validateWebpack(webpack) {
+    if (!webpack) {
+      this.errors.push('webpack 配置缺失');
+      return;
+    }
+
+    // 验证 entry
+    if (webpack.entry !== undefined) {
+      this._validateEntry(webpack.entry);
+    }
+
+    // 验证 resolve
+    if (webpack.resolve) {
+      this._validateResolve(webpack.resolve);
+    }
+
+    // 验证 externals
+    if (webpack.externals !== undefined) {
+      const validTypes = ['object', 'string', 'function'];
+      if (!validTypes.includes(typeof webpack.externals)) {
+        this.errors.push('webpack.externals 类型不正确');
+      }
+    }
+
+    // 验证 sassResources
+    if (webpack.sassResources !== undefined) {
+      if (!Array.isArray(webpack.sassResources)) {
+        this.errors.push('webpack.sassResources 必须是数组');
+      }
+    }
+
+    // 验证 babelPlugins
+    if (webpack.babelPlugins !== undefined) {
+      const validTypes = ['function', 'object'];
+      const type = Array.isArray(webpack.babelPlugins) ? 'object' : typeof webpack.babelPlugins;
+      if (!validTypes.includes(type)) {
+        this.errors.push('webpack.babelPlugins 必须是数组或函数');
+      }
+    }
+
+    // 验证 moduleRules
+    if (webpack.moduleRules !== undefined && !Array.isArray(webpack.moduleRules)) {
+      this.errors.push('webpack.moduleRules 必须是数组');
+    }
+
+    // 验证 plugins
+    if (webpack.plugins !== undefined && !Array.isArray(webpack.plugins)) {
+      this.errors.push('webpack.plugins 必须是数组');
+    }
+  }
+
+  /**
+   * 验证 entry 配置
+   * @private
+   */
+  _validateEntry(entry) {
+    if (entry === undefined || entry === null) {
+      return;
+    }
+
+    const type = typeof entry;
+
+    if (type === 'string') {
+      // 单个入口文件
+      return;
+    }
+
+    if (Array.isArray(entry)) {
+      // 数组形式的入口
+      entry.forEach((item, index) => {
+        if (typeof item !== 'string') {
+          this.errors.push(`entry[${index}] 必须是字符串`);
+        }
+      });
+      return;
+    }
+
+    if (type === 'object') {
+      // 对象形式的入口
+      Object.keys(entry).forEach((key) => {
+        const value = entry[key];
+        if (typeof value !== 'string' && !Array.isArray(value)) {
+          this.errors.push(`entry.${key} 必须是字符串或数组`);
+        }
+        if (Array.isArray(value)) {
+          value.forEach((item, index) => {
+            if (typeof item !== 'string') {
+              this.errors.push(`entry.${key}[${index}] 必须是字符串`);
+            }
+          });
+        }
+      });
+      return;
+    }
+
+    this.errors.push('entry 配置格式不正确');
+  }
+
+  /**
+   * 验证 resolve 配置
+   * @private
+   */
+  _validateResolve(resolve) {
+    if (resolve.extensions !== undefined) {
+      if (!Array.isArray(resolve.extensions)) {
+        this.errors.push('webpack.resolve.extensions 必须是数组');
+      } else {
+        resolve.extensions.forEach((ext, index) => {
+          if (typeof ext !== 'string') {
+            this.errors.push(`webpack.resolve.extensions[${index}] 必须是字符串`);
+          } else if (!ext.startsWith('.')) {
+            this.warnings.push(`webpack.resolve.extensions[${index}] (${ext}) 建议以 "." 开头`);
+          }
+        });
+      }
+    }
+
+    if (resolve.alias !== undefined && typeof resolve.alias !== 'object') {
+      this.errors.push('webpack.resolve.alias 必须是对象');
+    }
+  }
+
+  /**
+   * 验证 dev 配置
+   * @private
+   */
+  _validateDev(dev) {
+    if (!dev) {
+      this.errors.push('dev 配置缺失');
+      return;
+    }
+
+    // 验证 NODE_ENV
+    if (dev.NODE_ENV && typeof dev.NODE_ENV !== 'string') {
+      this.errors.push('dev.NODE_ENV 必须是字符串');
+    }
+
+    // 验证端口
+    if (dev.port !== undefined) {
+      this._validatePort(dev.port, 'dev.port');
+    }
+
+    // 验证布尔值字段
+    const booleanFields = ['autoOpenBrowser', 'cssSourceMap', 'https', 'closeHotReload'];
+    booleanFields.forEach((field) => {
+      if (dev[field] !== undefined && typeof dev[field] !== 'boolean') {
+        this.errors.push(`dev.${field} 必须是布尔值`);
+      }
+    });
+
+    // 验证字符串字段
+    const stringFields = ['assetsPublicPath', 'assetsSubDirectory', 'hostname'];
+    stringFields.forEach((field) => {
+      if (dev[field] !== undefined && typeof dev[field] !== 'string') {
+        this.errors.push(`dev.${field} 必须是字符串`);
+      }
+    });
+
+    // 验证 proxyTable
+    if (dev.proxyTable !== undefined && typeof dev.proxyTable !== 'object') {
+      this.errors.push('dev.proxyTable 必须是对象');
+    }
+  }
+
+  /**
+   * 验证 build 配置
+   * @private
+   */
+  _validateBuild(build) {
+    if (!build) {
+      this.errors.push('build 配置缺失');
+      return;
+    }
+
+    this._validateBuildCommon(build, 'build');
+  }
+
+  /**
+   * 验证 build2lib 配置
+   * @private
+   */
+  _validateBuild2Lib(build2lib) {
+    if (!build2lib) return;
+
+    this._validateBuildCommon(build2lib, 'build2lib');
+
+    // 验证 libraryName
+    if (build2lib.libraryName !== undefined && typeof build2lib.libraryName !== 'string') {
+      this.errors.push('build2lib.libraryName 必须是字符串');
+    }
+  }
+
+  /**
+   * 验证 build2esm 配置
+   * @private
+   */
+  _validateBuild2Esm(build2esm) {
+    if (!build2esm) return;
+
+    // 验证 input
+    if (build2esm.input !== undefined && typeof build2esm.input !== 'string') {
+      this.errors.push('build2esm.input 必须是字符串');
+    }
+
+    // 验证 fileName
+    if (build2esm.fileName !== undefined && typeof build2esm.fileName !== 'string') {
+      this.errors.push('build2esm.fileName 必须是字符串');
+    }
+
+    // 验证 type
+    if (build2esm.type !== undefined) {
+      const validTypes = ['ts', 'js'];
+      if (!validTypes.includes(build2esm.type)) {
+        this.errors.push(`build2esm.type 必须是 ${validTypes.join(' 或 ')}`);
+      }
+    }
+
+    // 验证 compress
+    if (build2esm.compress !== undefined && typeof build2esm.compress !== 'boolean') {
+      this.errors.push('build2esm.compress 必须是布尔值');
+    }
+
+    // 验证 declaration
+    if (build2esm.declaration !== undefined && typeof build2esm.declaration !== 'boolean') {
+      this.errors.push('build2esm.declaration 必须是布尔值');
+    }
+
+    // 验证 excludeList
+    if (build2esm.excludeList !== undefined && !Array.isArray(build2esm.excludeList)) {
+      this.errors.push('build2esm.excludeList 必须是数组');
+    }
+  }
+
+  /**
+   * 验证通用的 build 配置项
+   * @private
+   */
+  _validateBuildCommon(buildConfig, prefix) {
+    // 验证 NODE_ENV
+    if (buildConfig.NODE_ENV && typeof buildConfig.NODE_ENV !== 'string') {
+      this.errors.push(`${prefix}.NODE_ENV 必须是字符串`);
+    }
+
+    // 验证路径字段
+    const pathFields = ['assetsRoot', 'assetsPublicPath', 'assetsSubDirectory'];
+    pathFields.forEach((field) => {
+      if (buildConfig[field] !== undefined && typeof buildConfig[field] !== 'string') {
+        this.errors.push(`${prefix}.${field} 必须是字符串`);
+      }
+    });
+
+    // 验证布尔值字段
+    const booleanFields = ['productionSourceMap', 'productionGzip', 'bundleAnalyzerReport'];
+    booleanFields.forEach((field) => {
+      if (buildConfig[field] !== undefined && typeof buildConfig[field] !== 'boolean') {
+        this.errors.push(`${prefix}.${field} 必须是布尔值`);
+      }
+    });
+
+    // 验证 productionGzipExtensions
+    if (buildConfig.productionGzipExtensions !== undefined) {
+      if (!Array.isArray(buildConfig.productionGzipExtensions)) {
+        this.errors.push(`${prefix}.productionGzipExtensions 必须是数组`);
+      }
+    }
+  }
+
+  /**
+   * 验证 envParams 配置
+   * @private
+   */
+  _validateEnvParams(envParams) {
+    if (!envParams) return;
+
+    if (typeof envParams !== 'object') {
+      this.errors.push('envParams 必须是对象');
+      return;
+    }
+
+    // 验证每个环境的参数
+    Object.keys(envParams).forEach((env) => {
+      if (typeof envParams[env] !== 'object') {
+        this.errors.push(`envParams.${env} 必须是对象`);
+      }
+    });
+  }
+
+  /**
+   * 验证端口号
+   * @private
+   */
+  _validatePort(port, fieldName) {
+    const portNum = parseInt(port, 10);
+
+    if (isNaN(portNum)) {
+      this.errors.push(`${fieldName} 必须是数字`);
+      return;
+    }
+
+    if (portNum < 1 || portNum > 65535) {
+      this.errors.push(`${fieldName} 必须在 1-65535 之间`);
+      return;
+    }
+
+    if (portNum < 1024 && process.platform !== 'win32') {
+      this.warnings.push(
+        `${fieldName} (${portNum}) 小于 1024，在非 Windows 系统上可能需要管理员权限`
+      );
+    }
+  }
+
+  /**
+   * 获取错误列表
+   * @returns {Array}
+   */
+  getErrors() {
+    return this.errors;
+  }
+
+  /**
+   * 获取警告列表
+   * @returns {Array}
+   */
+  getWarnings() {
+    return this.warnings;
+  }
+
+  /**
+   * 是否有错误
+   * @returns {boolean}
+   */
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+
+  /**
+   * 是否有警告
+   * @returns {boolean}
+   */
+  hasWarnings() {
+    return this.warnings.length > 0;
+  }
+}
+
+/**
+ * 验证配置（便捷方法）
+ * @param {Object} config - 配置对象
+ * @returns {Object} 验证后的配置
+ */
+function validateConfig(config) {
+  const validator = new ConfigValidator();
+  return validator.validate(config);
+}
+
+module.exports = {
+  ConfigValidator,
+  validateConfig
+};