mm_config 2.1.3 → 2.1.5

package/README.md

@@ -1,194 +1,284 @@
-# mm_config
-
-超级美眉配置帮助类，动态同步文件修改配置。
-
-## 功能特点
-
-- 支持配置文件的动态读取和修改
-- 修改配置后自动同步保存到JSON文件
-- 使用Proxy实现属性监听，操作方便
-- 支持同步和异步API操作
-- 支持配置修改防抖功能，减少频繁保存
-- 内置错误处理机制，提高稳定性
-- 支持JSON5格式配置文件
-- 向后兼容原有API
-
-## 安装
-
-```bash
-npm install mm_config
-```
-
-## API说明
-
-### 导入模块
-
-```javascript
-// 导入同步配置创建函数（默认）
-const conf = require('mm_config');
-
-// 导入异步配置创建函数
-const createConfigAsync = conf.createConfigAsync;
-
-// 导入配置管理器类
-const { ConfigManager } = require('mm_config');
-```
-
-### 配置初始化
-
-#### 同步API
-
-```javascript
-/**
- * 创建同步配置管理器
- * @param {Object} _config 配置对象，可选，不传则从文件读取
- * @param {String} _jsonFile 配置文件路径，可选，不传则使用this.filename
- * @param {Object} options 配置选项，可选
- * @param {Number} options.debounceTime 防抖时间(ms)，默认0
- * @param {Boolean} options.pretty 是否美化输出，默认true
- * @param {String} options.format 格式(json/json5)，默认json
- * @returns {Proxy} 返回配置代理对象
- */
-const config = conf(_config, _jsonFile, options);
-```
-
-#### 异步API
-
-```javascript
-/**
- * 创建异步配置管理器
- * @param {Object} _config 配置对象，可选，不传则从文件读取
- * @param {String} _jsonFile 配置文件路径，可选，不传则使用this.filename
- * @param {Object} options 配置选项，可选
- * @returns {Promise<Proxy>} 返回配置代理对象的Promise
- */
-const config = await createConfigAsync(_config, _jsonFile, options);
-```
-
-#### 代理对象特殊方法
-
-通过代理对象可以访问以下特殊方法：
-
-- `_saveSync()`: 同步保存配置到文件
-- `_saveAsync()`: 异步保存配置到文件
-- `_raw`: 获取原始配置对象
-
-## 使用示例
-
-### 1. 基本同步配置（兼容原API）
-
-```javascript
-// 创建配置并指定保存路径
-const config = conf({
-    name: "demo",
-    state: 1
-}, "./config.json");
-
-// 修改配置会自动保存到文件
-config.name = "test";
-config.sort = 2;
-
-// 显式调用保存
-config._saveSync();
-
-// 读取现有配置
-const existingConfig = conf(null, "./config.json");
-```
-
-### 2. 使用异步API
-
-```javascript
-async function setupConfig() {
-    // 创建异步配置
-    const config = await createConfigAsync({
-        name: "asyncDemo",
-        version: "1.0.0"
-    }, "./async_config.json");
-    
-    // 修改配置会异步自动保存
-    config.timestamp = new Date().toISOString();
-    
-    // 显式调用异步保存
-    await config._saveAsync();
-    
-    return config;
-}
-```
-
-### 3. 使用防抖功能
-
-```javascript
-// 创建带防抖的配置（500ms延迟保存）
-const debouncedConfig = conf({
-    name: "debounceDemo"
-}, "./debounce_config.json", {
-    debounceTime: 500 // 500ms防抖时间
-});
-
-// 快速多次修改，只会在最后一次修改后500ms保存一次
-for (let i = 0; i < 10; i++) {
-    debouncedConfig.counter = i;
-    debouncedConfig.timestamp = new Date().toISOString();
-}
-```
-
-### 4. 使用JSON5格式
-
-```javascript
-// 创建支持JSON5格式的配置
-const json5Config = conf(null, "./config.json5", {
-    format: 'json5'
-});
-
-// JSON5格式支持注释、尾随逗号等特性
-json5Config.description = "This supports JSON5 format";
-```
-
-### 5. 直接使用ConfigManager类
-
-```javascript
-const { ConfigManager } = require('mm_config');
-
-// 创建配置管理器实例
-const manager = new ConfigManager({
-    name: "directDemo"
-}, "./direct_config.json");
-
-// 获取代理对象
-const config = manager.getProxy();
-
-// 使用配置
-config.version = "1.0.0";
-
-// 手动调用保存方法
-manager.saveSync();
-await manager.saveAsync();
-```
-
-## 配置选项
-
-创建配置时可提供以下选项：
-
-| 选项 | 类型 | 默认值 | 描述 |
-|------|------|--------|------|
-| debounceTime | Number | 0 | 防抖时间(毫秒)，设置后多次修改会延迟保存 |
-| pretty | Boolean | true | 是否美化JSON输出，设为false可生成压缩的JSON |
-| format | String | 'json' | 配置文件格式，可选'json'或'json5' |
-
-## 注意事项
-
-1. 配置文件会自动创建和同步
-2. 修改配置对象的属性会自动保存到文件
-3. 确保有文件的写入权限
-4. 使用防抖功能可以减少频繁的文件IO操作
-5. 异步API适合在非阻塞环境中使用
-6. 当使用JSON5格式时，保存仍使用标准JSON格式，但可读取JSON5格式的文件
-
-## 依赖
-
-- json5: 用于解析JSON5格式
-- mm_expand: 提供文件操作扩展
-
-## 许可证
-
-ISC License
+# mm_config
+
+超级美眉配置帮助类，动态同步文件修改配置。
+
+## 功能特点
+
+- 支持配置文件的动态读取和修改
+- 修改配置后自动同步保存到JSON文件
+- 使用Proxy实现属性监听，操作方便
+- 支持同步和异步API操作
+- 支持配置修改防抖功能，减少频繁保存
+- 内置错误处理机制，提高稳定性
+- 支持JSON5格式配置文件
+- 简洁命名，遵循单字优先原则
+- 内置缓存管理，避免重复创建配置实例
+
+## 安装
+
+```bash
+npm install mm_config
+```
+
+## API说明
+
+### 导入模块
+
+```javascript
+// 导入配置类
+const { Config, create, createAsync, clear, clearAll } = require('mm_config');
+```
+
+### 配置初始化
+
+#### 同步API
+
+```javascript
+/**
+ * 创建同步配置
+ * @param {String} file - 配置文件路径
+ * @param {Object} config - 配置对象，可选
+ * @param {Object} options - 配置选项，可选
+ * @param {Number} options.debounce_time - 防抖时间(ms)，默认0
+ * @param {Boolean} options.pretty - 是否美化输出，默认true
+ * @param {String} options.format - 格式(json/json5)，默认json
+ * @returns {Proxy} 返回配置代理对象
+ */
+const config = create(file, config, options);
+```
+
+#### 异步API
+
+```javascript
+/**
+ * 创建异步配置
+ * @param {String} file - 配置文件路径
+ * @param {Object} config - 配置对象，可选
+ * @param {Object} options - 配置选项，可选
+ * @returns {Promise<Proxy>} 返回配置代理对象的Promise
+ */
+const config = await createAsync(file, config, options);
+```
+
+#### 缓存管理API
+
+```javascript
+/**
+ * 清理指定文件配置缓存
+ * @param {String} file - 配置文件路径
+ */
+clear(file);
+
+/**
+ * 清理所有配置缓存
+ */
+clearAll();
+```
+
+#### 代理对象特殊方法
+
+通过代理对象可以访问以下特殊方法：
+
+- `_saveSync()`: 同步保存配置到文件
+- `_saveAsync()`: 异步保存配置到文件
+- `_raw`: 获取原始配置对象
+
+## 使用示例
+
+### 1. 基本同步配置
+
+```javascript
+const { create } = require('mm_config');
+
+// 创建配置并指定保存路径
+const config = create("./config.json", {
+    name: "demo",
+    state: 1
+});
+
+// 修改配置会自动保存到文件
+config.name = "test";
+config.sort = 2;
+
+// 显式调用保存
+config._saveSync();
+
+// 读取现有配置
+const existingConfig = create("./config.json");
+```
+
+### 2. 使用异步API
+
+```javascript
+const { createAsync } = require('mm_config');
+
+async function setupConfig() {
+    // 创建异步配置
+    const config = await createAsync("./async_config.json", {
+        name: "asyncDemo",
+        version: "1.0.0"
+    });
+    
+    // 修改配置会异步自动保存
+    config.timestamp = new Date().toISOString();
+    
+    // 显式调用异步保存
+    await config._saveAsync();
+    
+    return config;
+}
+```
+
+### 3. 使用防抖功能
+
+```javascript
+const { create } = require('mm_config');
+
+// 创建带防抖的配置（500ms延迟保存）
+const config = create("./debounce_config.json", {
+    name: "debounceDemo"
+}, {
+    debounce_time: 500 // 500ms防抖时间
+});
+
+// 快速多次修改，只会在最后一次修改后500ms保存一次
+for (let i = 0; i < 10; i++) {
+    config.counter = i;
+    config.timestamp = new Date().toISOString();
+}
+```
+
+### 4. 使用JSON5格式
+
+```javascript
+const { create } = require('mm_config');
+
+// 创建支持JSON5格式的配置
+const config = create("./config.json5", null, {
+    format: 'json5'
+});
+
+// JSON5格式支持注释、尾随逗号等特性
+config.description = "This supports JSON5 format";
+```
+
+### 5. 直接使用Config类
+
+```javascript
+const { Config } = require('mm_config');
+
+// 创建配置实例
+const cfg = new Config({
+    name: "directDemo"
+}, "./direct_config.json");
+
+// 获取代理对象
+const config = cfg.getProxy();
+
+// 使用配置
+config.version = "1.0.0";
+
+// 手动调用保存方法
+cfg.saveSync();
+await cfg.saveAsync();
+```
+
+### 6. 使用配置操作方法
+
+```javascript
+const { Config } = require('mm_config');
+
+const cfg = new Config({}, "./methods_config.json");
+
+// 设置配置值
+await cfg.set("name", "test");
+
+// 获取配置值
+const name = await cfg.get("name");
+
+// 检查配置是否存在
+const hasName = await cfg.has("name");
+
+// 删除配置项
+await cfg.del("name");
+
+// 获取所有键
+const keys = await cfg.keys();
+```
+
+### 7. 缓存管理功能
+
+```javascript
+const { create, clear, clearAll } = require('mm_config');
+
+// 创建配置实例
+const config1 = create("./cache1.json", { test: "cache1" });
+const config2 = create("./cache2.json", { test: "cache2" });
+
+// 清理指定文件缓存
+clear("./cache1.json");
+
+// 重新创建会生成新实例
+const config1New = create("./cache1.json", { test: "cache1_new" });
+
+// 清理所有缓存
+clearAll();
+
+// 所有配置都会重新创建
+const config2New = create("./cache2.json", { test: "cache2_new" });
+```
+
+## 配置选项
+
+创建配置时可提供以下选项：
+
+| 选项 | 类型 | 默认值 | 描述 |
+|------|------|--------|------|
+| debounce_time | Number | 0 | 防抖时间(毫秒)，设置后多次修改会延迟保存 |
+| pretty | Boolean | true | 是否美化JSON输出，设为false可生成压缩的JSON |
+| format | String | 'json' | 配置文件格式，可选'json'或'json5' |
+
+## 注意事项
+
+1. 配置文件会自动创建和同步
+2. 修改配置对象的属性会自动保存到文件
+3. 确保有文件的写入权限
+4. 使用防抖功能可以减少频繁的文件IO操作
+5. 异步API适合在非阻塞环境中使用
+6. 当使用JSON5格式时，保存仍使用标准JSON格式，但可读取JSON5格式的文件
+7. 配置实例会被缓存，相同文件路径会返回同一实例，使用clear/clearAll可清理缓存
+
+## 依赖
+
+- json5: 用于解析JSON5格式
+- mm_expand: 提供文件操作扩展
+
+## 命名规范
+
+本模块遵循简洁命名原则：
+- 类名：`Config`（单字优先）
+- 方法名：`get()`、`set()`、`has()`、`del()`（动词开头）
+- 变量名：`val`、`key`、`bl`（简洁无废话）
+
+## 测试
+
+```bash
+# 运行测试
+npm test
+```
+
+## 许可证
+
+ISC License
+
+## 版本历史
+
+- v2.1.4: 添加缓存管理功能，修复内存泄漏问题
+- v2.1.3: 重构API，遵循简洁命名规范
+- v2.1.2: 添加JSON5格式支持
+- v2.1.1: 优化防抖功能
+- v2.1.0: 初始版本发布
+
+## 贡献
+
+欢迎提交Issue和Pull Request来改进这个项目。

package/index.js

@@ -1,199 +1,351 @@
-require('mm_logs');
-
-/**
- * 配置管理器类，提供同步和异步API
- */
-class ConfigManager {
-  /**
-   * 构造函数
-   * @param {Object} _config 配置对象
-   * @param {String} _jsonFile 配置文件路径
-   * @param {Object} options 配置选项
-   * @param {Number} options.debounceTime 防抖时间(ms)
-   * @param {Boolean} options.pretty 是否美化输出
-   * @param {String} options.format 格式(json/json5)
-   */
-  constructor(_config, _jsonFile, options = {}) {
-    this.config = _config || {};
-    this.filePath = _jsonFile;
-    this.options = {
-      debounceTime: 0, // 默认不防抖
-      pretty: true,
-      format: 'json',
-      ...options
-    };
-    this.writeTimer = null;
-    this.writePromise = Promise.resolve();
-
-    // 如果没有提供配置且有文件路径，则从文件加载
-    if (!_config && _jsonFile) {
-      try {
-        this.config = _jsonFile.loadJson();
-      } catch(error) {
-        $.log.error(`[Config] Error loading config from ${_jsonFile}:`, error.message);
-        this.config = {};
-      }
-    }
-  }
-
-  /**
-   * 保存配置到文件（同步）
-   */
-  saveSync() {
-    if (!this.filePath) return false;
-    try {
-      this.filePath.saveJson(this.config);
-      return true;
-    } catch(error) {
-      $.log.error(`[Config] Error saving config to ${this.filePath}:`, error.message);
-      return false;
-    }
-  }
-
-  /**
-   * 保存配置到文件（异步）
-   * @returns {Promise<Boolean>}
-   */
-  async saveAsync() {
-    if (!this.filePath) return Promise.resolve(true);
-
-    // 确保之前的写操作完成
-    await this.writePromise;
-
-    this.writePromise = Promise.resolve()
-      .then(() => {
-        this.filePath.saveJson(this.config);
-        return true;
-      })
-      .catch(error => {
-        $.log.error(`[Config] Error saving config to ${this.filePath}:`, error.message);
-        return false;
-      });
-
-    return this.writePromise;
-  }
-
-  /**
-   * 获取代理对象
-   * @returns {Proxy}
-   */
-  getProxy() {
-    const self = this;
-
-    return new Proxy(this.config, {
-      set(obj, prop, value) {
-        obj[prop] = value;
-
-        if (self.options.debounceTime > 0) {
-          // 防抖处理
-          if (self.writeTimer) {
-            clearTimeout(self.writeTimer);
-          }
-          self.writeTimer = setTimeout(() => {
-            self.saveSync();
-          }, self.options.debounceTime);
-        } else {
-          // 无防抖，直接保存
-          self.saveSync();
-        }
-
-        return true;
-      },
-
-      get(obj, prop) {
-        // 提供一些特殊属性访问
-        if (prop === '_saveAsync') {
-          return () => self.saveAsync();
-        }
-        if (prop === '_saveSync') {
-          return () => self.saveSync();
-        }
-        if (prop === '_raw') {
-          return obj;
-        }
-
-        return obj[prop];
-      }
-    });
-  }
-
-  /**
-   * 获取异步代理对象
-   * @returns {Proxy}
-   */
-  getAsyncProxy() {
-    const self = this;
-
-    return new Proxy(this.config, {
-      set(obj, prop, value) {
-        obj[prop] = value;
-
-        if (self.options.debounceTime > 0) {
-          if (self.writeTimer) {
-            clearTimeout(self.writeTimer);
-          }
-          self.writeTimer = setTimeout(() => {
-            self.saveAsync();
-          }, self.options.debounceTime);
-        } else {
-          self.saveAsync();
-        }
-
-        return true;
-      },
-
-      get(obj, prop) {
-        if (prop === '_saveAsync') {
-          return () => self.saveAsync();
-        }
-        if (prop === '_saveSync') {
-          return () => self.saveSync();
-        }
-        if (prop === '_raw') {
-          return obj;
-        }
-
-        return obj[prop];
-      }
-    });
-  }
+require('mm_expand');
+
+/**
+ * 配置类
+ * @class
+ */
+class Config {
+	/**
+	 * 创建配置实例
+	 * @param {Object} options - 配置对象
+	 * @param {String} file - 配置文件路径
+	 * @param {Object} config - 配置选项
+	 * @param {Number} config.debounce_time - 防抖时间(ms)
+	 * @param {Boolean} config.pretty - 是否美化输出
+	 * @param {String} config.format - 格式(json/json5)
+	 * @throws {TypeError} 当options非对象时
+	 * @throws {TypeError} 当file非字符串时
+	 */
+	constructor(options, file, config) {
+		// 参数校验
+		if (options && typeof options !== 'object') {
+			throw new TypeError('options must be an object');
+		}
+		if (file && typeof file !== 'string') {
+			throw new TypeError('file must be a string');
+		}
+
+		this.config = {
+			debounce_time: 0, // 默认不防抖
+			pretty: true,
+			format: 'json'
+		};
+		this.options = {};
+		this._file = file;
+		this._conn = null;
+		this._timer = null;
+		this._promise = Promise.resolve();
+
+		// 如果没有提供配置且有文件路径，则从文件加载
+		if (!options && file) {
+			try {
+				this.options = file.loadJson();
+			} catch (err) {
+				$.log.error(`[options] Error loading options from ${file}:`, err.message);
+				this.options = {};
+			}
+		}
+		// 设置配置
+		this.setOptions(options);
+		// 设置配置
+		this.setConfig(config);
+	}
+}
+
+/**
+ * 设置配置
+ * @param {Object} config - 配置对象
+ */
+Config.prototype.setConfig = function (config) {
+	Object.assign(this.config, config);
 }
 
 /**
- * 创建配置管理器的工厂函数
- * @param {Object} _config 配置对象
- * @param {String} _jsonFile 配置文件路径
- * @param {Object} options 配置选项
+ * 设置配置
+ * @param {Object} options - 配置对象
+ */
+Config.prototype.setOptions = function (options) {
+	$.push(this.options, options, true);
+}
+
+/**
+ * 初始化配置（连接文件）
+ * @param {Object} conn - 已连接的文件对象
+ * @returns {Promise} 连接结果
+ */
+Config.prototype.setup = async function (conn) {
+	if (conn) this._conn = conn;
+	return this._conn;
+};
+
+/**
+ * 保存配置到文件（同步）
+ * @returns {Boolean} 保存是否成功
+ */
+Config.prototype.saveSync = function () {
+	if (!this._file) return false;
+	try {
+		this._file.saveJson(this.options);
+		return true;
+	} catch (err) {
+		$.log.error(`[options] Error saving options to ${this._file}:`, err.message);
+		return false;
+	}
+};
+
+/**
+ * 保存配置到文件（异步）
+ * @returns {Promise<Boolean>}
+ */
+Config.prototype.saveAsync = async function () {
+	if (!this._file) return Promise.resolve(true);
+
+	// 确保之前的写操作完成
+	await this._promise;
+
+	this._promise = Promise.resolve()
+		.then(() => {
+			this._file.saveJson(this.options);
+			return true;
+		})
+		.catch(err => {
+			$.log.error(`[options] Error saving options to ${this._file}:`, err.message);
+			return false;
+		});
+
+	return this._promise;
+};
+
+/**
+ * 获取代理对象
+ * @returns {Proxy}
+ */
+Config.prototype.getProxy = function () {
+	var self = this;
+
+	return new Proxy(this.options, {
+		set(obj, prop, val) {
+			obj[prop] = val;
+
+			if (self.config.debounce_time > 0) {
+				// 防抖处理
+				if (self._timer) {
+					clearTimeout(self._timer);
+				}
+				self._timer = setTimeout(() => {
+					self.saveSync();
+				}, self.config.debounce_time);
+			} else {
+				// 无防抖，直接保存
+				self.saveSync();
+			}
+
+			return true;
+		},
+
+		get(obj, prop) {
+			// 提供一些特殊属性访问
+			if (prop === '_saveAsync') {
+				return () => self.saveAsync();
+			}
+			if (prop === '_saveSync') {
+				return () => self.saveSync();
+			}
+			if (prop === '_raw') {
+				return obj;
+			}
+
+			return obj[prop];
+		}
+	});
+};
+
+/**
+ * 获取异步代理对象
  * @returns {Proxy}
  */
-function createConfig(_config, _jsonFile, options = {}) {
-  // 兼容旧的调用方式（this.filename）
-  if (!_jsonFile && this && this.filename) {
-    _jsonFile = this.filename;
-  }
+Config.prototype.getAsyncProxy = function () {
+	var self = this;
 
-  const manager = new ConfigManager(_config, _jsonFile, options);
-  return manager.getProxy(); // 默认返回同步代理
+	return new Proxy(this.options, {
+		set(obj, prop, val) {
+			obj[prop] = val;
+
+			if (self.config.debounce_time > 0) {
+				if (self._timer) {
+					clearTimeout(self._timer);
+				}
+				self._timer = setTimeout(() => {
+					self.saveAsync();
+				}, self.config.debounce_time);
+			} else {
+				self.saveAsync();
+			}
+
+			return true;
+		},
+
+		get(obj, prop) {
+			if (prop === '_saveAsync') {
+				return () => self.saveAsync();
+			}
+			if (prop === '_saveSync') {
+				return () => self.saveSync();
+			}
+			if (prop === '_raw') {
+				return obj;
+			}
+
+			return obj[prop];
+		}
+	});
+};
+
+/**
+ * 配置字典（私有）
+ * @type {Object}
+ */
+const dict = {};
+
+/**
+ * 创建配置（同步）
+ * @param {String} file - 配置文件路径
+ * @param {Object} options - 配置对象
+ * @param {Object} config - 配置选项
+ * @returns {Proxy}
+ */
+function create(file, options = {}, config = {}) {
+	let f = file.fullname();
+	// 检查是否已存在配置
+	if (dict[f]) {
+		// $.log.warn(`[options] Config for file ${f} already exists.`);
+		return dict[f].getProxy();
+	}
+	var cfg = new Config(options, f, config);
+	cfg.saveSync(); // 确保文件存在
+	// 注册配置字典
+	dict[f] = cfg;
+	return dict[f].getProxy();
 }
 
 /**
- * 创建异步配置管理器的工厂函数
- * @param {Object} _config 配置对象
- * @param {String} _jsonFile 配置文件路径
- * @param {Object} options 配置选项
+ * 创建配置（异步）
+ * @param {String} file - 配置文件路径
+ * @param {Object} options - 配置对象
+ * @param {Object} config - 配置选项
  * @returns {Promise<Proxy>}
  */
-async function createConfigAsync(_config, _jsonFile, options = {}) {
-  // 兼容旧的调用方式（this.filename）
-  if (!_jsonFile && this && this.filename) {
-    _jsonFile = this.filename;
-  }
+async function createAsync(file, options = {}, config = {}) {
+	let f = file.fullname();
+	// 检查是否已存在配置
+	if (dict[f]) {
+		$.log.warn(`[options] Config for file ${f} already exists.`);
+		return dict[f].getAsyncProxy();
+	}
+	var cfg = new Config(options, f, config);
+	await cfg.saveAsync(); // 确保文件存在
+	// 注册配置字典
+	dict[f] = cfg;
+	return dict[f].getAsyncProxy();
+}
 
-  const manager = new ConfigManager(_config, _jsonFile, options);
-  return manager.getAsyncProxy();
+/**
+ * 清理指定文件配置缓存
+ * @param {String} file - 配置文件路径
+ */
+function clear(file) {
+	if (!file) return clearAll();
+	let f = file.fullname();
+	if (dict[f]) {
+		delete dict[f];
+	}
 }
 
-// 导出工厂函数和类
-module.exports = createConfig;
-module.exports.createConfigAsync = createConfigAsync;
-module.exports.ConfigManager = ConfigManager;
+/**
+ * 清理所有配置缓存
+ */
+function clearAll() {
+	Object.keys(dict).forEach(key => {
+		delete dict[key];
+	});
+}
+
+/**
+ * 获取配置值
+ * @param {String} key - 配置键
+ * @returns {*}
+ */
+Config.prototype.get = async function (key) {
+	var value;
+	if (this._conn) {
+		value = await this._conn.get(key);
+	}
+	if (!value) {
+		value = this.options[key];
+	}
+	return value;
+};
+
+/**
+ * 设置配置值
+ * @param {String} key - 配置键
+ * @param {*} value - 配置值
+ */
+Config.prototype.set = async function (key, value) {
+	if (this._conn) {
+		await this._conn.set(key, value);
+	}
+	else {
+		this.options[key] = value;
+	}
+};
+
+/**
+ * 检查配置是否存在
+ * @param {String} key - 配置键
+ * @returns {Boolean}
+ */
+Config.prototype.has = async function (key) {
+	var bl = false;
+	if (this._conn) {
+		bl = await this._conn.has(key);
+	};
+	if (!bl) {
+		bl = this.options.hasOwnProperty(key);
+	}
+	return bl;
+};
+
+/**
+ * 删除配置项
+ * @param {String} key - 配置键
+ */
+Config.prototype.del = async function (key) {
+	if (this._conn) {
+		await this._conn.del(key);
+	};
+	delete this.options[key];
+};
+
+/**
+ * 获取所有配置键
+ * @returns {Array<String>}
+ */
+Config.prototype.keys = async function () {
+	let keys = [];
+	if (this._conn) {
+		keys = await this._conn.keys();
+	}
+	let local_keys = Object.keys(this.options);
+	keys = keys.concat(local_keys);
+	return keys;
+};
+
+// 模块导出
+module.exports = {
+	Config,
+	create,
+	createAsync,
+	clear,
+	clearAll
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_config",
-    "version": "2.1.3",
+    "version": "2.1.5",
     "description": "这是超级美眉配置同步器,用于更改配置同步保存为JSON文件",
     "main": "index.js",
     "scripts": {
@@ -26,6 +26,6 @@
     },
     "homepage": "https://gitee.com/qiuwenwu91/mm_config#readme",
     "dependencies": {
-        "mm_logs": "^1.5.1"
+        "mm_expand": "^1.9.7"
     }
-}
+}

package/test.js

@@ -1,132 +1,199 @@
-const conf = require('./index.js');
-const createConfigAsync = conf.createConfigAsync;
+const { create, createAsync, Config, clear, clearAll } = require('./index.js');
 
-// 测试同步API（向后兼容）
+// 测试同步API
 function testSyncConfig() {
-  console.log('=== 测试同步配置 API（向后兼容）===');
-  
+  $.log.debug('=== 测试同步配置 API ===');
+
   // 方式1：提供配置对象和文件路径
-  const config1 = conf({
+  const config1 = create("./config1.json", {
     name: "demo",
     state: 1
-  }, "./config1.json");
-  
+  });
+
   // 修改配置，会自动保存
   config1.name = "test1";
   config1.sort = 1;
-  console.log('配置1:', config1);
-  
-  // 方式2：使用this.filename（兼容旧用法）
-  const context = {
-    filename: "./config2.json"
-  };
-  
-  const config2 = conf.call(context, {
-    name: "demo",
-    state: 2
-  });
-  
+  $.log.debug('配置1:', config1);
+
+  // 方式2：创建空配置
+  const config2 = create("./config2.json");
+
   config2.name = "test2";
   config2.sort = 2;
-  console.log('配置2:', config2);
-  
+  $.log.debug('配置2:', config2);
+
   // 从文件加载配置
-  const config3 = conf(null, "./config1.json");
-  console.log('从文件加载的配置:', config3);
-  
+  const config3 = create("./config1.json");
+  $.log.debug('从文件加载的配置:', config3);
+
   // 手动保存
   config3.age = 26;
   config3._saveSync(); // 显式调用保存
-  console.log('更新后的配置3:', config3);
+  $.log.debug('更新后的配置3:', config3);
 }
 
 // 测试异步API
 async function testAsyncConfig() {
-  console.log('\n=== 测试异步配置 API ===');
-  
+  $.log.debug('\n=== 测试异步配置 API ===');
+
   try {
     // 创建异步配置
-    const configAsync = await createConfigAsync({
+    const configAsync = await createAsync("./config_async.json", {
       name: "asyncDemo",
       state: 3
-    }, "./config_async.json");
-    
+    });
+
     // 修改配置，会异步自动保存
     configAsync.name = "asyncTest2";
     configAsync.timestamp = new Date().toISOString();
-    console.log('异步配置:', configAsync);
-    
+    $.log.debug('异步配置:', configAsync);
+
     // 显式调用异步保存
     // await configAsync._saveAsync();
-    console.log('异步保存完成');
-    
-  } catch (error) {
-    console.error('异步配置测试出错:', error);
+    $.log.debug('异步保存完成');
+
+  } catch (err) {
+    $.log.error('异步配置测试出错:', err);
   }
 }
 
 // 测试高级功能：防抖
 function testDebounce() {
-  console.log('\n=== 测试防抖功能 ===');
-  
+  $.log.debug('\n=== 测试防抖功能 ===');
+
   // 创建带防抖的配置（500ms延迟保存）
-  const configDebounce = conf({
+  const configDebounce = create("./config_debounce.json", {
     name: "debounceDemo"
-  }, "./config_debounce.json", {
-    debounceTime: 500, // 500ms防抖时间
+  }, {
+    debounce_time: 500, // 500ms防抖时间
     pretty: true       // 美化JSON输出
   });
-  
+
   // 快速多次修改，应该只保存最后一次
-  console.log('开始多次快速修改...');
+  $.log.debug('开始多次快速修改...');
   for (let i = 0; i < 5; i++) {
     configDebounce.value = i;
     configDebounce.timestamp = new Date().toISOString();
   }
-  
-  console.log('修改完成，等待防抖触发保存...');
-  console.log('最终配置:', configDebounce);
+
+  $.log.debug('修改完成，等待防抖触发保存...');
+  $.log.debug('最终配置:', configDebounce);
 }
 
 // 测试JSON5格式
 function testJson5() {
-  console.log('\n=== 测试JSON5格式支持 ===');
-  
+  $.log.debug('\n=== 测试JSON5格式支持 ===');
+
   // 创建配置时指定JSON5格式
-  const configJson5 = conf({
-    name: "json5Demo",
-    // JSON5支持的一些特性，如注释、尾随逗号等
-    // 虽然保存时会转为标准JSON，但读取时可以处理JSON5格式
-  }, "./config_json5.json", {
+  const configJson5 = create("./config_json5.json", {
+    name: "json5Demo"
+  }, {
     format: 'json5',
     pretty: true
   });
-  
+
   configJson5.description = "This uses JSON5 format";
-  console.log('JSON5配置:', configJson5);
+  $.log.debug('JSON5配置:', configJson5);
+}
+
+/**
+ * 测试配置方法
+ */
+async function testMethods() {
+  $.log.debug('\n=== 测试配置方法 ===');
+
+  // 创建测试配置
+  const cg = new Config({
+    name: "methodsDemo",
+    sort: 100,
+    state: 1
+  });
+
+  // 测试设置和获取
+  await cg.set('name', 'testMethods');
+  const name = await cg.get('name');
+  $.log.debug('获取到的名称:', name);
+
+  // 测试检查存在
+  const hasName = await cg.has('name');
+  $.log.debug('是否存在名称:', hasName);
+
+  // 测试删除
+  await cg.del('name');
+  const hasNameAfterDelete = await cg.has('name');
+  $.log.debug('删除后是否存在名称:', hasNameAfterDelete);
+
+  // 测试获取所有键
+  const keys = await cg.keys();
+  $.log.debug('所有键:', keys);
+
+  const state = await cg.get('state');
+  $.log.debug('获取到的状态:', state);
+
+  // 测试设置选项
+  await cg.setOptions({
+    sort: 200,
+    state: "2"
+  });
+  $.log.debug('设置后的选项:', await cg.options);
+}
+
+// 测试缓存清理功能
+async function testCacheClear() {
+  $.log.debug('\n=== 测试缓存清理功能 ===');
+
+  // 创建几个配置实例
+  const config1 = create("./cache_test1.json", { test: "cache1" });
+  const config2 = create("./cache_test2.json", { test: "cache2" });
+  const config3 = await createAsync("./cache_test3.json", { test: "cache3" });
+
+  $.log.debug('创建了3个配置实例');
+
+  // 测试清理单个缓存
+  clear("./cache_test1.json");
+  $.log.debug('已清理cache_test1.json的缓存');
+
+  // 重新创建应该会创建新实例
+  const config1New = create("./cache_test1.json", { test: "cache1_new" });
+  $.log.debug('重新创建cache_test1.json');
+
+  // 测试清理所有缓存
+  clearAll();
+  $.log.debug('已清理所有缓存');
+
+  // 再次创建应该都是新实例
+  const config2New = create("./cache_test2.json", { test: "cache2_new" });
+  const config3New = await createAsync("./cache_test3.json", { test: "cache3_new" });
+  $.log.debug('重新创建所有配置实例');
 }
 
 // 运行所有测试
 async function runAllTests() {
-  console.log('开始运行配置管理器测试...');
-  
+  $.log.debug('开始运行配置管理器测试...');
+
   // 运行同步测试
   testSyncConfig();
-  
+
   // 运行异步测试
   await testAsyncConfig();
-  
+
   // 运行防抖测试
   testDebounce();
-  
+
   // 运行JSON5测试
   testJson5();
-  
-  console.log('\n所有测试完成！');
-  console.log('请查看生成的配置文件以验证保存结果。');
+
+  // 运行缓存清理测试
+  await testCacheClear();
+
+  $.log.debug('\n所有测试完成！');
+  $.log.debug('请查看生成的配置文件以验证保存结果。');
+
+  // 运行方法测试
+  await testMethods();
 }
 
 // 执行测试
 runAllTests().catch(err => {
-  console.error('测试过程中出现错误:', err);
+  $.log.error('测试过程中出现错误:', err);
 });

package/base.js

@@ -1,30 +0,0 @@
-/**
- * 重够配置，同步保存
- * @param {Object} _config 配置对象
- * @param {String} _jsonFile 配置文件
- */
-module.exports = function(_config, _jsonFile) {
-	if (!_jsonFile) {
-		_jsonFile = this.filename;
-	}
-	if (!_config) {
-		try {
-			_config = _jsonFile.loadJson();
-		} catch (error) {
-			_config = {};
-		}
-	}
-	return new Proxy(_config, {
-		set: function(obj, prop, value) {
-			obj[prop] = value;
-			if (_jsonFile) {
-				try {
-					_jsonFile.saveJson(obj); // 使用saveJson原型函数，参数为对象和缩进空格数
-				} catch (error) {
-					console.error('[Config] 保存配置失败:', error);
-				}
-			}
-			return true
-		}
-	});
-}

package/config.json

@@ -1,6 +0,0 @@
-{
-    "name": "test",
-    "state": 2,
-    "sort": 2,
-    "age": 26
-}