@pisell/core 0.0.2

package/lib/indexDB/index.js

@@ -0,0 +1,767 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/indexDB/index.ts
+var indexDB_exports = {};
+__export(indexDB_exports, {
+  default: () => indexDB_default,
+  mockPromise: () => mockPromise
+});
+module.exports = __toCommonJS(indexDB_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_dexie = __toESM(require("dexie"));
+var mockPromise = (data, timeout = 200) => {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      resolve(data);
+    }, timeout);
+  });
+};
+var IndexDBManager = class _IndexDBManager {
+  /**
+   * 检查环境是否支持 IndexedDB
+   * @returns {boolean} 是否支持 IndexedDB
+   * @private
+   */
+  static isSupported() {
+    return typeof window !== "undefined" && "indexedDB" in window;
+  }
+  db = null;
+  dbName;
+  version;
+  stores;
+  useIndexDB;
+  app;
+  // 内存存储：每个 store 使用一个 Map，key 为主键，value 为数据
+  memoryStorage = /* @__PURE__ */ new Map();
+  // 操作超时时间（毫秒）
+  timeout = 1e4;
+  // ===== 防抖 add 相关 =====
+  // 每个 store 一个 buffer
+  debouncedBuffers = /* @__PURE__ */ new Map();
+  // 每个 store 一个 timer
+  debouncedTimers = /* @__PURE__ */ new Map();
+  // 正在 flush 的 store
+  debouncedFlushing = /* @__PURE__ */ new Set();
+  // 防抖时间（ms）
+  debouncedDelay = 200;
+  // 单次事务最大写入条数
+  debouncedBatchSize = 50;
+  // ===== 防抖 update 相关 =====
+  // 每个 store 一个 Map（key -> data）
+  debouncedUpdateBuffers = /* @__PURE__ */ new Map();
+  debouncedUpdateTimers = /* @__PURE__ */ new Map();
+  debouncedUpdateFlushing = /* @__PURE__ */ new Set();
+  debouncedUpdateDelay = 200;
+  debouncedUpdateBatchSize = 50;
+  /**
+   * 创建 IndexDBManager 实例
+   * @param {DBOptions} options - 数据库配置选项
+   */
+  constructor(app, options) {
+    this.app = app;
+    this.dbName = options.dbName;
+    this.version = options.version;
+    this.stores = options.stores;
+    this.useIndexDB = _IndexDBManager.isSupported();
+    this.timeout = options.timeout ?? 1e4;
+    if (!this.useIndexDB) {
+      this.stores.forEach((store) => {
+        this.memoryStorage.set(store.name, /* @__PURE__ */ new Map());
+      });
+    }
+  }
+  /**
+   * 超时包装器 - 为 Promise 添加超时控制
+   * @param {Promise<T>} promise - 需要包装的 Promise
+   * @param {string} operation - 操作名称（用于错误提示）
+   * @returns {Promise<T>} 带超时控制的 Promise
+   * @private
+   */
+  withTimeout(promise, operation) {
+    let timeoutId = null;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        const error = new Error(`操作超时: ${operation} 在 ${this.timeout}ms 内未完成`);
+        this.app.logger.addLog({
+          type: "error",
+          title: "[ IndexDB ] TIMEOUT",
+          metadata: {
+            msg: `操作超时: ${operation}`,
+            timeout: this.timeout,
+            operation
+          }
+        });
+        reject(error);
+      }, this.timeout);
+    });
+    return Promise.race([
+      promise.then(
+        (result) => {
+          if (timeoutId) clearTimeout(timeoutId);
+          return result;
+        },
+        (error) => {
+          if (timeoutId) clearTimeout(timeoutId);
+          throw error;
+        }
+      ),
+      timeoutPromise
+    ]);
+  }
+  /**
+   * 初始化数据库连接
+   * 如果环境不支持 IndexedDB，将自动使用内存存储
+   * @returns {Promise<boolean>} 连接是否成功
+   */
+  async connect() {
+    if (!this.useIndexDB) {
+      return true;
+    }
+    return this.withTimeout(
+      (async () => {
+        try {
+          this.db = new import_dexie.default(this.dbName);
+          const schema = {};
+          this.stores.forEach((store) => {
+            var _a;
+            const indexes = ((_a = store.indexes) == null ? void 0 : _a.map((index) => {
+              var _a2, _b;
+              let indexStr = index.name;
+              if ((_a2 = index.options) == null ? void 0 : _a2.unique) {
+                indexStr = `&${indexStr}`;
+              }
+              if ((_b = index.options) == null ? void 0 : _b.multiEntry) {
+                indexStr = `*${indexStr}`;
+              }
+              return indexStr;
+            })) || [];
+            const primaryKey = store.keyPath;
+            schema[store.name] = [primaryKey, ...indexes].join(",");
+          });
+          this.db.version(this.version).stores(schema);
+          await this.db.open();
+          this.db.on("blocked", () => {
+            this.app.logger.addLog({
+              type: "error",
+              title: "[ IndexDB ] blocked",
+              metadata: { msg: "DB blocked" }
+            });
+          });
+          this.db.on("close", () => {
+            this.app.logger.addLog({
+              type: "error",
+              title: "[ IndexDB ] CLOSE",
+              metadata: { msg: "DB close" }
+            });
+          });
+          return true;
+        } catch (error) {
+          this.app.logger.addLog({
+            type: "error",
+            title: "[ IndexDB ] ERROR",
+            metadata: { msg: "DB request error", message: error.message }
+          });
+          throw error;
+        }
+      })(),
+      "connect"
+    );
+  }
+  /**
+   * 获取内存存储中指定 store 的 Map
+   * @param {string} storeName - 存储对象名称
+   * @returns {Map<string | number, any>} 存储 Map
+   * @private
+   */
+  getMemoryStore(storeName) {
+    let store = this.memoryStorage.get(storeName);
+    if (!store) {
+      store = /* @__PURE__ */ new Map();
+      this.memoryStorage.set(storeName, store);
+    }
+    return store;
+  }
+  /**
+  * 防抖合并 add（用于高频写入场景）
+  * @param storeName 存储对象名称
+  * @param data 数据
+  */
+  debouncedAdd(storeName, data) {
+    if (!this.db) return;
+    if (!this.debouncedBuffers.has(storeName)) {
+      this.debouncedBuffers.set(storeName, []);
+    }
+    this.debouncedBuffers.get(storeName).push(data);
+    if (this.debouncedFlushing.has(storeName)) return;
+    const oldTimer = this.debouncedTimers.get(storeName);
+    if (oldTimer) clearTimeout(oldTimer);
+    this.debouncedTimers.set(
+      storeName,
+      setTimeout(() => {
+        this.flushDebouncedAdd(storeName);
+      }, this.debouncedDelay)
+    );
+  }
+  /**
+  * 立即 flush 指定 store 的防抖 add
+  */
+  async flushDebouncedAdd(storeName) {
+    if (!this.useIndexDB || !this.db) return;
+    if (this.debouncedFlushing.has(storeName)) return;
+    const buffer = this.debouncedBuffers.get(storeName);
+    if (!buffer || buffer.length === 0) return;
+    this.debouncedFlushing.add(storeName);
+    const uuid = `[ IndexDB ] DEBOUNCED_ADD: - ${storeName} - ${(0, import_dayjs.default)().valueOf()}`;
+    try {
+      while (buffer.length > 0) {
+        const batch = buffer.splice(0, this.debouncedBatchSize);
+        for (const item of batch) {
+          await mockPromise({}, this.debouncedDelay);
+          try {
+            await this.add(storeName, item);
+          } catch (err) {
+          }
+        }
+      }
+    } catch (error) {
+      this.app.logger.addLog({
+        type: "error",
+        title: uuid,
+        metadata: {
+          msg: "防抖合并 add 失败",
+          error: error.message
+        }
+      });
+    } finally {
+      this.debouncedFlushing.delete(storeName);
+    }
+  }
+  /**
+  * 防抖合并 update（同 key 自动合并）
+  */
+  debouncedUpdate(storeName, data) {
+    if (!this.useIndexDB) {
+      const storeConfig2 = this.stores.find((s) => s.name === storeName);
+      const keyPath2 = (storeConfig2 == null ? void 0 : storeConfig2.keyPath) || "id";
+      const key2 = data[keyPath2];
+      this.getMemoryStore(storeName).set(key2, {
+        ...this.getMemoryStore(storeName).get(key2),
+        ...data
+      });
+      return;
+    }
+    if (!this.db) return;
+    const storeConfig = this.stores.find((s) => s.name === storeName);
+    const keyPath = (storeConfig == null ? void 0 : storeConfig.keyPath) || "id";
+    const key = data[keyPath];
+    if (key == null) {
+      console.warn(`[IndexDB] debouncedUpdate missing keyPath: ${keyPath}`);
+      return;
+    }
+    if (!this.debouncedUpdateBuffers.has(storeName)) {
+      this.debouncedUpdateBuffers.set(storeName, /* @__PURE__ */ new Map());
+    }
+    const storeBuffer = this.debouncedUpdateBuffers.get(storeName);
+    storeBuffer.set(key, {
+      ...storeBuffer.get(key) || {},
+      ...data
+    });
+    if (this.debouncedUpdateFlushing.has(storeName)) return;
+    const oldTimer = this.debouncedUpdateTimers.get(storeName);
+    if (oldTimer) clearTimeout(oldTimer);
+    this.debouncedUpdateTimers.set(
+      storeName,
+      setTimeout(() => {
+        this.flushDebouncedUpdate(storeName);
+      }, this.debouncedUpdateDelay)
+    );
+  }
+  /**
+   * flush 防抖 update
+   */
+  async flushDebouncedUpdate(storeName) {
+    if (!this.useIndexDB || !this.db) return;
+    if (this.debouncedUpdateFlushing.has(storeName)) return;
+    const bufferMap = this.debouncedUpdateBuffers.get(storeName);
+    if (!bufferMap || bufferMap.size === 0) return;
+    this.debouncedUpdateFlushing.add(storeName);
+    const uuid = `[ IndexDB ] DEBOUNCED_UPDATE: - ${storeName} - ${(0, import_dayjs.default)().valueOf()}`;
+    try {
+      const entries = Array.from(bufferMap.values());
+      bufferMap.clear();
+      for (let i = 0; i < entries.length; i += this.debouncedUpdateBatchSize) {
+        const batch = entries.slice(i, i + this.debouncedUpdateBatchSize);
+        for (const item of batch) {
+          await mockPromise(item, this.debouncedUpdateDelay);
+          try {
+            await this.update(storeName, item);
+          } catch (err) {
+          }
+        }
+      }
+    } catch (error) {
+      this.app.logger.addLog({
+        type: "error",
+        title: uuid,
+        metadata: {
+          msg: "防抖合并 update 失败",
+          error: error.message
+        }
+      });
+    } finally {
+      this.debouncedUpdateFlushing.delete(storeName);
+    }
+  }
+  /**
+    * 添加数据到指定的存储对象
+    * @param {string} storeName - 存储对象名称
+    * @param {T} data - 要添加的数据
+  * * @param {boolean} [log=true] - 是否记录日志
+    * @returns {Promise<T>} 添加的数据
+    * @template T
+    */
+  async add(storeName, data, log = false) {
+    if (!this.useIndexDB) {
+      const storeConfig = this.stores.find((s) => s.name === storeName);
+      const keyPath = (storeConfig == null ? void 0 : storeConfig.keyPath) || "id";
+      const key = data[keyPath];
+      const memStore = this.getMemoryStore(storeName);
+      memStore.set(key, data);
+      return data;
+    }
+    const uuid = `[ IndexDB ] ADD: - ${storeName} - ${(0, import_dayjs.default)().valueOf()}`;
+    if (log) {
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          if (log) {
+            this.app.logger.addLog({
+              type: "error",
+              title: uuid,
+              metadata: { msg: "添加数据前 数据库未连接", data }
+            });
+          }
+          throw new Error("数据库未连接");
+        }
+        try {
+          await this.db.table(storeName).add(data);
+          return data;
+        } catch (error) {
+          const issExists = ((error == null ? void 0 : error.message) || "").includes("exists");
+          this.app.logger.addLog({
+            type: issExists ? "info" : "error",
+            title: uuid,
+            metadata: {
+              msg: "添加数据失败",
+              data,
+              error: error.message
+            }
+          });
+          throw new Error(error == null ? void 0 : error.message);
+        }
+      })(),
+      `add(${storeName})`
+    );
+  }
+  /**
+   * 快速检查指定存储对象中的数据是否存在
+   * @param {string} storeName - 存储对象名称
+   * @param {string|number} key - 数据主键
+   * @returns {Promise<boolean>} 数据是否存在
+   */
+  async exists(storeName, key) {
+    if (!this.useIndexDB) {
+      const memStore = this.getMemoryStore(storeName);
+      return memStore.has(key);
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          const result = await this.db.table(storeName).get(key);
+          return result !== void 0;
+        } catch (error) {
+          throw new Error("检查数据存在性失败");
+        }
+      })(),
+      `exists(${storeName})`
+    );
+  }
+  /**
+   * 获取指定存储对象中的数据
+   * @param {string} storeName - 存储对象名称
+   * @param {string|number} key - 数据主键
+   * * @param {boolean} [log=true] - 是否记录日志
+   * @returns {Promise<T|null>} 获取的数据，不存在则返回 null
+   * @template T
+   */
+  async get(storeName, key, log = false) {
+    const uuid = `[ IndexDB ] GET: - ${storeName} - ${key} - ${(0, import_dayjs.default)().valueOf()}`;
+    if (log) {
+    }
+    if (!this.useIndexDB) {
+      const memStore = this.getMemoryStore(storeName);
+      return memStore.get(key) ?? null;
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          if (log) {
+            this.app.logger.addLog({
+              type: "error",
+              title: uuid,
+              metadata: { msg: "数据库未连接" }
+            });
+          }
+          throw new Error("数据库未连接");
+        }
+        try {
+          const result = await this.db.table(storeName).get(key);
+          if (log) {
+          }
+          return result ?? null;
+        } catch (error) {
+          if (log) {
+            this.app.logger.addLog({
+              type: "error",
+              title: uuid,
+              metadata: { msg: "获取失败", error: error.message }
+            });
+          }
+          throw new Error("获取数据失败");
+        }
+      })(),
+      `get(${storeName})`
+    );
+  }
+  /**
+   * 更新指定存储对象中的数据
+   * @param {string} storeName - 存储对象名称
+   * @param {T} data - 要更新的数据
+   * * @param {boolean} [log=true] - 是否记录日志
+   * @returns {Promise<T>} 更新后的数据
+   * @template T
+   */
+  async update(storeName, data, log = false) {
+    if (!this.useIndexDB) {
+      const storeConfig = this.stores.find((s) => s.name === storeName);
+      const keyPath = (storeConfig == null ? void 0 : storeConfig.keyPath) || "id";
+      const key = data[keyPath];
+      const memStore = this.getMemoryStore(storeName);
+      memStore.set(key, data);
+      return data;
+    }
+    const uuid = `[ IndexDB ] UPDATE: - ${storeName} - ${(0, import_dayjs.default)().valueOf()}`;
+    if (log) {
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          if (log) {
+            this.app.logger.addLog({
+              type: "error",
+              title: uuid,
+              metadata: { msg: "数据库未连接" }
+            });
+          }
+          throw new Error("数据库未连接");
+        }
+        try {
+          await this.db.table(storeName).put(data);
+          if (log) {
+          }
+          return data;
+        } catch (error) {
+          this.app.logger.addLog({
+            type: "error",
+            title: uuid,
+            metadata: { msg: "数据更新失败", error: error.message }
+          });
+          throw new Error(error == null ? void 0 : error.message);
+        }
+      })(),
+      `update(${storeName})`
+    );
+  }
+  /**
+   * 删除指定存储对象中的数据
+   * @param {string} storeName - 存储对象名称
+   * @param {string|number} key - 数据主键
+   * @returns {Promise<boolean>} 删除是否成功
+   */
+  async delete(storeName, key) {
+    if (!this.useIndexDB) {
+      const memStore = this.getMemoryStore(storeName);
+      return memStore.delete(key);
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          await this.db.table(storeName).delete(key);
+          return true;
+        } catch (error) {
+          throw new Error("删除数据失败");
+        }
+      })(),
+      `delete(${storeName})`
+    );
+  }
+  /**
+   * 通过索引获取数据
+   * @param {string} storeName - 存储对象名称
+   * @param {string} indexName - 索引名称
+   * @param {string|number} indexValue - 索引值
+   * @returns {Promise<T|null>} 获取的数据，不存在则返回 null
+   * @template T
+   */
+  async getByIndex(storeName, indexName, indexValue) {
+    var _a;
+    if (!this.useIndexDB) {
+      const allData = await this.getAll(storeName);
+      const storeConfig = this.stores.find((s) => s.name === storeName);
+      const index = (_a = storeConfig == null ? void 0 : storeConfig.indexes) == null ? void 0 : _a.find((i) => i.name === indexName);
+      if (!index) return null;
+      return allData.find((item) => item[index.keyPath] === indexValue) || null;
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          const result = await this.db.table(storeName).where(indexName).equals(indexValue).first();
+          return result || null;
+        } catch (error) {
+          throw new Error("通过索引获取数据失败");
+        }
+      })(),
+      `getByIndex(${storeName}, ${indexName})`
+    );
+  }
+  /**
+   * 通过索引检查数据是否存在
+   * @param {string} storeName - 存储对象名称
+   * @param {string} indexName - 索引名称
+   * @param {string|number} indexValue - 索引值
+   * @returns {Promise<boolean>} 数据是否存在
+   */
+  async existsByIndex(storeName, indexName, indexValue) {
+    var _a;
+    if (!this.useIndexDB) {
+      const allData = await this.getAll(storeName);
+      const storeConfig = this.stores.find((s) => s.name === storeName);
+      const index = (_a = storeConfig == null ? void 0 : storeConfig.indexes) == null ? void 0 : _a.find((i) => i.name === indexName);
+      if (!index) return false;
+      return allData.some((item) => item[index.keyPath] === indexValue);
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          const count = await this.db.table(storeName).where(indexName).equals(indexValue).count();
+          return count > 0;
+        } catch (error) {
+          throw new Error("通过索引检查数据存在性失败");
+        }
+      })(),
+      `existsByIndex(${storeName}, ${indexName})`
+    );
+  }
+  /**
+   * 通过索引获取多条数据
+   * @param {string} storeName - 存储对象名称
+   * @param {string} indexName - 索引名称
+   * @param {string|number} indexValue - 索引值
+   * @returns {Promise<T[]>} 数据数组
+   * @template T
+   */
+  async getAllByIndex(storeName, indexName, indexValue) {
+    var _a;
+    if (!this.useIndexDB) {
+      const allData = await this.getAll(storeName);
+      const storeConfig = this.stores.find((s) => s.name === storeName);
+      const index = (_a = storeConfig == null ? void 0 : storeConfig.indexes) == null ? void 0 : _a.find((i) => i.name === indexName);
+      if (!index) return [];
+      return allData.filter((item) => item[index.keyPath] === indexValue);
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          const results = await this.db.table(storeName).where(indexName).equals(indexValue).toArray();
+          return results;
+        } catch (error) {
+          throw new Error("通过索引获取多条数据失败");
+        }
+      })(),
+      `getAllByIndex(${storeName}, ${indexName})`
+    );
+  }
+  /**
+   * 统计指定存储对象中的数据数量
+   * @param {string} storeName - 存储对象名称
+   * @returns {Promise<number>} 数据数量
+   */
+  async count(storeName) {
+    if (!this.useIndexDB) {
+      const allData = await this.getAll(storeName);
+      return allData.length;
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          const count = await this.db.table(storeName).count();
+          return count;
+        } catch (error) {
+          throw new Error("统计数据数量失败");
+        }
+      })(),
+      `count(${storeName})`
+    );
+  }
+  /**
+   * 通过索引统计数据数量
+   * @param {string} storeName - 存储对象名称
+   * @param {string} indexName - 索引名称
+   * @param {string|number} indexValue - 索引值
+   * @returns {Promise<number>} 数据数量
+   */
+  async countByIndex(storeName, indexName, indexValue) {
+    if (!this.useIndexDB) {
+      const matchingData = await this.getAllByIndex(storeName, indexName, indexValue);
+      return matchingData.length;
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          const count = await this.db.table(storeName).where(indexName).equals(indexValue).count();
+          return count;
+        } catch (error) {
+          throw new Error("通过索引统计数据数量失败");
+        }
+      })(),
+      `countByIndex(${storeName}, ${indexName})`
+    );
+  }
+  /**
+   * 获取指定存储对象中的所有数据
+   * @param {string} storeName - 存储对象名称
+   * @returns {Promise<T[]>} 数据数组
+   * @template T
+   */
+  async getAll(storeName) {
+    if (!this.useIndexDB) {
+      const memStore = this.getMemoryStore(storeName);
+      return Array.from(memStore.values());
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          const results = await this.db.table(storeName).toArray();
+          return results;
+        } catch (error) {
+          this.app.logger.addLog({
+            type: "error",
+            title: `[ IndexDB ] ERROR: - getAll(${storeName})`,
+            metadata: { msg: "获取所有数据失败", error: error.message }
+          });
+          throw new Error(error == null ? void 0 : error.message);
+        }
+      })(),
+      `getAll(${storeName})`
+    );
+  }
+  /**
+   * 清空指定存储对象中的所有数据
+   * @param {string} storeName - 存储对象名称
+   * @returns {Promise<boolean>} 清空是否成功
+   */
+  async clear(storeName) {
+    if (!this.useIndexDB) {
+      const memStore = this.getMemoryStore(storeName);
+      memStore.clear();
+      return true;
+    }
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          await this.db.table(storeName).clear();
+          return true;
+        } catch (error) {
+          throw new Error("清空数据失败");
+        }
+      })(),
+      `clear(${storeName})`
+    );
+  }
+  /**
+   * 关闭数据库连接
+   * 在不再需要使用数据库时调用，释放资源
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  /**
+   * 获取当前使用的存储方式
+   * @returns {'indexDB'|'memory'} 当前使用的存储方式
+   */
+  getCurrentStorage() {
+    return this.useIndexDB ? "indexDB" : "memory";
+  }
+};
+var indexDB_default = IndexDBManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mockPromise
+});