@pisell/core 1.1.4 → 1.1.6

package/lib/indexDB/index.js

@@ -33,6 +33,7 @@ __export(indexDB_exports, {
 });
 module.exports = __toCommonJS(indexDB_exports);
 var import_dayjs = __toESM(require("dayjs"));
+var import_dexie = __toESM(require("dexie"));
 var IndexDBManager = class _IndexDBManager {
   /**
    * 检查环境是否支持 IndexedDB
@@ -40,7 +41,7 @@ var IndexDBManager = class _IndexDBManager {
    * @private
    */
   static isSupported() {
-    return window && "indexedDB" in window;
+    return typeof window !== "undefined" && "indexedDB" in window;
   }
   db = null;
   dbName;
@@ -48,6 +49,10 @@ var IndexDBManager = class _IndexDBManager {
   stores;
   useIndexDB;
   app;
+  // 内存存储：每个 store 使用一个 Map，key 为主键，value 为数据
+  memoryStorage = /* @__PURE__ */ new Map();
+  // 操作超时时间（毫秒）
+  timeout = 5e3;
   /**
    * 创建 IndexDBManager 实例
    * @param {DBOptions} options - 数据库配置选项
@@ -58,70 +63,123 @@ var IndexDBManager = class _IndexDBManager {
     this.version = options.version;
     this.stores = options.stores;
     this.useIndexDB = _IndexDBManager.isSupported();
+    this.timeout = options.timeout ?? 5e3;
+    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，将自动使用 localStorage
+   * 如果环境不支持 IndexedDB，将自动使用内存存储
    * @returns {Promise<boolean>} 连接是否成功
    */
   async connect() {
     if (!this.useIndexDB) {
       return true;
     }
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, this.version);
-      request.onerror = (event) => {
-        var _a, _b;
-        this.app.logger.addLog({
-          type: "error",
-          title: "[ IndexDB ] ERROR",
-          metadata: { msg: "DB request error", data: event, message: (_b = (_a = event == null ? void 0 : event.target) == null ? void 0 : _a.error) == null ? void 0 : _b.message }
-        });
-      };
-      request.onsuccess = (event) => {
-        this.db = event.target.result;
-        resolve(true);
-      };
-      request.onblocked = () => {
-        this.app.logger.addLog({
-          type: "error",
-          title: "[ IndexDB ] blocked",
-          metadata: { msg: "DB blocked" }
-        });
-      };
-      request.onupgradeneeded = (event) => {
-      };
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
-        db.onerror = (event2) => {
-          var _a, _b;
+    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 error", data: event2, message: (_b = (_a = event2 == null ? void 0 : event2.target) == null ? void 0 : _a.error) == null ? void 0 : _b.message }
+            metadata: { msg: "DB request error", message: error.message }
           });
-        };
-        this.stores.forEach((store) => {
-          var _a;
-          if (!db.objectStoreNames.contains(store.name)) {
-            const objectStore = db.createObjectStore(store.name, { keyPath: store.keyPath });
-            (_a = store.indexes) == null ? void 0 : _a.forEach((index) => {
-              objectStore.createIndex(index.name, index.keyPath, index.options);
-            });
-          }
-        });
-      };
-    });
+          throw error;
+        }
+      })(),
+      "connect"
+    );
   }
   /**
-   * 生成用于 localStorage 的存储键
+   * 获取内存存储中指定 store 的 Map
    * @param {string} storeName - 存储对象名称
-   * @param {string|number} [key] - 可选的键值
-   * @returns {string} 格式化的存储键
+   * @returns {Map<string | number, any>} 存储 Map
    * @private
    */
-  getStorageKey(storeName, key) {
-    return `${this.dbName}_${storeName}${key ? `_${key}` : ""}`;
+  getMemoryStore(storeName) {
+    let store = this.memoryStorage.get(storeName);
+    if (!store) {
+      store = /* @__PURE__ */ new Map();
+      this.memoryStorage.set(storeName, store);
+    }
+    return store;
   }
   /**
     * 添加数据到指定的存储对象
@@ -132,10 +190,12 @@ var IndexDBManager = class _IndexDBManager {
     * @template T
     */
   async add(storeName, data, log = false) {
-    var _a;
     if (!this.useIndexDB) {
-      const key = this.getStorageKey(storeName, data[((_a = this.stores.find((s) => s.name === storeName)) == null ? void 0 : _a.keyPath) || "id"]);
-      this.app.storage.setStorage(key, JSON.stringify(data));
+      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()}`;
@@ -146,73 +206,47 @@ var IndexDBManager = class _IndexDBManager {
         metadata: { msg: "添加数据前", data }
       });
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        if (log) {
-          this.app.logger.addLog({
-            type: "error",
-            title: uuid,
-            metadata: { msg: "添加数据前 数据库未连接", data }
-          });
-        }
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readwrite");
-      const store = transaction.objectStore(storeName);
-      const request = store.add(data);
-      request.onsuccess = () => {
-        if (log) {
-          this.app.logger.addLog({
-            type: "info",
-            title: uuid,
-            metadata: { msg: "添加数据成功" }
-          });
-        }
-        return resolve(data);
-      };
-      request.onerror = () => {
-        if (log) {
-          this.app.logger.addLog({
-            type: "error",
-            title: uuid,
-            metadata: { msg: "添加数据失败" }
-          });
-        }
-        return reject(new Error("添加数据失败"));
-      };
-      transaction.oncomplete = () => {
-        console.log("✅ 添加事务完成");
-        if (log) {
-          this.app.logger.addLog({
-            type: "info",
-            title: uuid,
-            metadata: { msg: "事务完成" }
-          });
-        }
-        return;
-      };
-      transaction.onerror = (e) => {
-        if (log) {
-          this.app.logger.addLog({
-            type: "error",
-            title: uuid,
-            metadata: { msg: "事务错误" }
-          });
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          if (log) {
+            this.app.logger.addLog({
+              type: "error",
+              title: uuid,
+              metadata: { msg: "添加数据前 数据库未连接", data }
+            });
+          }
+          throw new Error("数据库未连接");
         }
-        return reject(transaction.error ?? new Error("事务错误"));
-      };
-      transaction.onabort = (e) => {
-        if (log) {
-          this.app.logger.addLog({
-            type: "error",
-            title: uuid,
-            metadata: { msg: "事务被中止" }
-          });
+        try {
+          await this.db.table(storeName).add(data);
+          if (log) {
+            this.app.logger.addLog({
+              type: "info",
+              title: uuid,
+              metadata: { msg: "添加数据成功" }
+            });
+            console.log("✅ 添加事务完成");
+            this.app.logger.addLog({
+              type: "info",
+              title: uuid,
+              metadata: { msg: "事务完成" }
+            });
+          }
+          return data;
+        } catch (error) {
+          if (log) {
+            this.app.logger.addLog({
+              type: "error",
+              title: uuid,
+              metadata: { msg: "添加数据失败", error: error.message }
+            });
+          }
+          throw new Error("添加数据失败");
         }
-        return reject(new Error("事务被中止"));
-      };
-    });
+      })(),
+      `add(${storeName})`
+    );
   }
   /**
    * 快速检查指定存储对象中的数据是否存在
@@ -222,20 +256,23 @@ var IndexDBManager = class _IndexDBManager {
    */
   async exists(storeName, key) {
     if (!this.useIndexDB) {
-      const storageKey = this.getStorageKey(storeName, key);
-      return this.app.storage.getStorage(storageKey) !== null;
+      const memStore = this.getMemoryStore(storeName);
+      return memStore.has(key);
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readonly");
-      const store = transaction.objectStore(storeName);
-      const request = store.count(key);
-      request.onsuccess = () => resolve(request.result > 0);
-      request.onerror = () => reject(new Error("检查数据存在性失败"));
-    });
+    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})`
+    );
   }
   /**
    * 获取指定存储对象中的数据
@@ -255,85 +292,49 @@ var IndexDBManager = class _IndexDBManager {
       });
     }
     if (!this.useIndexDB) {
-      const storageKey = this.getStorageKey(storeName, key);
-      let data = this.app.storage.getStorage(storageKey);
-      if (data) {
-        data = JSON.parse(data);
-      }
-      return data;
+      const memStore = this.getMemoryStore(storeName);
+      return memStore.get(key) ?? null;
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        if (log) {
-          this.app.logger.addLog({
-            type: "error",
-            title: uuid,
-            metadata: { msg: "数据库未连接" }
-          });
-        }
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      let resolved = false;
-      try {
-        const transaction = this.db.transaction(storeName, "readonly");
-        const store = transaction.objectStore(storeName);
-        const request = store.get(key);
-        request.onsuccess = () => {
-          resolved = true;
-          if (log) {
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "获取成功" }
-            });
-          }
-          resolve(request.result ?? null);
-        };
-        request.onerror = () => {
-          resolved = true;
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
           if (log) {
             this.app.logger.addLog({
               type: "error",
               title: uuid,
-              metadata: { msg: "获取失败" }
+              metadata: { msg: "数据库未连接" }
             });
           }
-          reject(request.error ?? new Error("获取数据失败"));
-        };
-        transaction.onabort = () => {
+          throw new Error("数据库未连接");
+        }
+        try {
+          const result = await this.db.table(storeName).get(key);
           if (log) {
             this.app.logger.addLog({
               type: "info",
               title: uuid,
-              metadata: { msg: "事务被中止" }
+              metadata: { msg: "获取成功" }
             });
-          }
-          if (!resolved) reject(new Error("事务被中止"));
-        };
-        transaction.onerror = (event) => {
-          if (log) {
             this.app.logger.addLog({
-              type: "error",
+              type: "info",
               title: uuid,
-              metadata: { msg: `事务错误: ${event.target.error}` }
+              metadata: { msg: "事务完成" }
             });
           }
-          if (!resolved) reject(new Error(`事务错误: ${event.target.error}`));
-        };
-        transaction.oncomplete = () => {
+          return result ?? null;
+        } catch (error) {
           if (log) {
             this.app.logger.addLog({
-              type: "info",
+              type: "error",
               title: uuid,
-              metadata: { msg: "事务完成" }
+              metadata: { msg: "获取失败", error: error.message }
             });
           }
-        };
-      } catch (e) {
-        reject(e);
-      }
-    });
+          throw new Error("获取数据失败");
+        }
+      })(),
+      `get(${storeName})`
+    );
   }
   /**
    * 更新指定存储对象中的数据
@@ -344,10 +345,12 @@ var IndexDBManager = class _IndexDBManager {
    * @template T
    */
   async update(storeName, data, log = false) {
-    var _a;
     if (!this.useIndexDB) {
-      const key = this.getStorageKey(storeName, data[((_a = this.stores.find((s) => s.name === storeName)) == null ? void 0 : _a.keyPath) || "id"]);
-      this.app.storage.setStorage(key, JSON.stringify(data));
+      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()}`;
@@ -358,76 +361,47 @@ var IndexDBManager = class _IndexDBManager {
         metadata: { msg: "更新数据前", data }
       });
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        if (log) {
-          this.app.logger.addLog({
-            type: "error",
-            title: uuid,
-            metadata: { msg: "数据库未连接" }
-          });
-        }
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      try {
-        const transaction = this.db.transaction(storeName, "readwrite");
-        const store = transaction.objectStore(storeName);
-        const request = store.put(data);
-        request.onsuccess = () => {
-          if (log) {
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "数据更新完成" }
-            });
-          }
-          return resolve(data);
-        };
-        request.onerror = () => {
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
           if (log) {
             this.app.logger.addLog({
               type: "error",
               title: uuid,
-              metadata: { msg: "数据更新失败" }
+              metadata: { msg: "数据库未连接" }
             });
           }
-          return reject(request.error ?? new Error("更新数据失败"));
-        };
-        transaction.oncomplete = () => {
+          throw new Error("数据库未连接");
+        }
+        try {
+          await this.db.table(storeName).put(data);
           if (log) {
             this.app.logger.addLog({
               type: "info",
               title: uuid,
-              metadata: { msg: "事务完成" }
+              metadata: { msg: "数据更新完成" }
             });
-          }
-          return console.log("✅ 事务完成");
-        };
-        transaction.onabort = (e) => {
-          if (log) {
+            console.log("✅ 事务完成");
             this.app.logger.addLog({
-              type: "error",
+              type: "info",
               title: uuid,
-              metadata: { msg: "事务被中止" }
+              metadata: { msg: "事务完成" }
             });
           }
-          return reject(new Error("事务被中止"));
-        };
-        transaction.onerror = (e) => {
+          return data;
+        } catch (error) {
           if (log) {
             this.app.logger.addLog({
               type: "error",
               title: uuid,
-              metadata: { msg: "事务错误" }
+              metadata: { msg: "数据更新失败", error: error.message }
             });
           }
-          return reject(transaction.error ?? new Error("事务错误"));
-        };
-      } catch (e) {
-        reject(e);
-      }
-    });
+          throw new Error("更新数据失败");
+        }
+      })(),
+      `update(${storeName})`
+    );
   }
   /**
    * 删除指定存储对象中的数据
@@ -437,21 +411,23 @@ var IndexDBManager = class _IndexDBManager {
    */
   async delete(storeName, key) {
     if (!this.useIndexDB) {
-      const storageKey = this.getStorageKey(storeName, key);
-      this.app.storage.removeStorage(storageKey);
-      return true;
+      const memStore = this.getMemoryStore(storeName);
+      return memStore.delete(key);
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readwrite");
-      const store = transaction.objectStore(storeName);
-      const request = store.delete(key);
-      request.onsuccess = () => resolve(true);
-      request.onerror = () => reject(new Error("删除数据失败"));
-    });
+    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})`
+    );
   }
   /**
    * 通过索引获取数据
@@ -470,18 +446,20 @@ var IndexDBManager = class _IndexDBManager {
       if (!index) return null;
       return allData.find((item) => item[index.keyPath] === indexValue) || null;
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readonly");
-      const store = transaction.objectStore(storeName);
-      const index = store.index(indexName);
-      const request = index.get(indexValue);
-      request.onsuccess = () => resolve(request.result || null);
-      request.onerror = () => reject(new Error("通过索引获取数据失败"));
-    });
+    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})`
+    );
   }
   /**
    * 通过索引检查数据是否存在
@@ -499,18 +477,20 @@ var IndexDBManager = class _IndexDBManager {
       if (!index) return false;
       return allData.some((item) => item[index.keyPath] === indexValue);
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readonly");
-      const store = transaction.objectStore(storeName);
-      const index = store.index(indexName);
-      const request = index.count(indexValue);
-      request.onsuccess = () => resolve(request.result > 0);
-      request.onerror = () => reject(new Error("通过索引检查数据存在性失败"));
-    });
+    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})`
+    );
   }
   /**
    * 通过索引获取多条数据
@@ -529,18 +509,20 @@ var IndexDBManager = class _IndexDBManager {
       if (!index) return [];
       return allData.filter((item) => item[index.keyPath] === indexValue);
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readonly");
-      const store = transaction.objectStore(storeName);
-      const index = store.index(indexName);
-      const request = index.getAll(indexValue);
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(new Error("通过索引获取多条数据失败"));
-    });
+    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})`
+    );
   }
   /**
    * 统计指定存储对象中的数据数量
@@ -552,17 +534,20 @@ var IndexDBManager = class _IndexDBManager {
       const allData = await this.getAll(storeName);
       return allData.length;
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readonly");
-      const store = transaction.objectStore(storeName);
-      const request = store.count();
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(new Error("统计数据数量失败"));
-    });
+    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})`
+    );
   }
   /**
    * 通过索引统计数据数量
@@ -576,18 +561,20 @@ var IndexDBManager = class _IndexDBManager {
       const matchingData = await this.getAllByIndex(storeName, indexName, indexValue);
       return matchingData.length;
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readonly");
-      const store = transaction.objectStore(storeName);
-      const index = store.index(indexName);
-      const request = index.count(indexValue);
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(new Error("通过索引统计数据数量失败"));
-    });
+    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})`
+    );
   }
   /**
    * 获取指定存储对象中的所有数据
@@ -597,33 +584,23 @@ var IndexDBManager = class _IndexDBManager {
    */
   async getAll(storeName) {
     if (!this.useIndexDB) {
-      const prefix = this.getStorageKey(storeName);
-      const results = [];
-      for (let i = 0; i < localStorage.length; i++) {
-        const key = localStorage.key(i);
-        if (key == null ? void 0 : key.startsWith(prefix)) {
-          let value = this.app.storage.getStorage(key);
-          if (value) {
-            value = JSON.parse(value);
-          }
-          if (value) {
-            results.push(value);
-          }
-        }
-      }
-      return results;
+      const memStore = this.getMemoryStore(storeName);
+      return Array.from(memStore.values());
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readonly");
-      const store = transaction.objectStore(storeName);
-      const request = store.getAll();
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(new Error("获取所有数据失败"));
-    });
+    return this.withTimeout(
+      (async () => {
+        if (!this.db) {
+          throw new Error("数据库未连接");
+        }
+        try {
+          const results = await this.db.table(storeName).toArray();
+          return results;
+        } catch (error) {
+          throw new Error("获取所有数据失败");
+        }
+      })(),
+      `getAll(${storeName})`
+    );
   }
   /**
    * 清空指定存储对象中的所有数据
@@ -632,28 +609,24 @@ var IndexDBManager = class _IndexDBManager {
    */
   async clear(storeName) {
     if (!this.useIndexDB) {
-      const prefix = this.getStorageKey(storeName);
-      const keysToRemove = [];
-      for (let i = 0; i < localStorage.length; i++) {
-        const key = localStorage.key(i);
-        if (key == null ? void 0 : key.startsWith(prefix)) {
-          keysToRemove.push(key);
-        }
-      }
-      keysToRemove.forEach((key) => this.app.storage.removeStorage(key));
+      const memStore = this.getMemoryStore(storeName);
+      memStore.clear();
       return true;
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      const transaction = this.db.transaction(storeName, "readwrite");
-      const store = transaction.objectStore(storeName);
-      const request = store.clear();
-      request.onsuccess = () => resolve(true);
-      request.onerror = () => reject(new Error("清空数据失败"));
-    });
+    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})`
+    );
   }
   /**
    * 关闭数据库连接
@@ -667,10 +640,10 @@ var IndexDBManager = class _IndexDBManager {
   }
   /**
    * 获取当前使用的存储方式
-   * @returns {'indexDB'|'localStorage'} 当前使用的存储方式
+   * @returns {'indexDB'|'memory'} 当前使用的存储方式
    */
   getCurrentStorage() {
-    return this.useIndexDB ? "indexDB" : "localStorage";
+    return this.useIndexDB ? "indexDB" : "memory";
   }
 };
 var indexDB_default = IndexDBManager;