@pisell/core 1.1.3 → 1.1.5

package/lib/indexDB/index.js

@@ -48,6 +48,10 @@ var IndexDBManager = class _IndexDBManager {
   stores;
   useIndexDB;
   app;
+  // 内存存储：每个 store 使用一个 Map，key 为主键，value 为数据
+  memoryStorage = /* @__PURE__ */ new Map();
+  // 操作超时时间（毫秒）
+  timeout = 5e3;
   /**
    * 创建 IndexDBManager 实例
    * @param {DBOptions} options - 数据库配置选项
@@ -58,49 +62,129 @@ 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 = () => {
-        this.useIndexDB = false;
-        resolve(true);
-      };
-      request.onsuccess = (event) => {
-        this.db = event.target.result;
-        resolve(true);
-      };
-      request.onupgradeneeded = (event) => {
-        const db = event.target.result;
-        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);
+    return this.withTimeout(
+      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;
+            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 }
             });
-          }
-        });
-      };
-    });
+          };
+          db.onclose = (event2) => {
+            var _a, _b;
+            this.app.logger.addLog({
+              type: "error",
+              title: "[ IndexDB ] CLOSE",
+              metadata: { msg: "DB close", data: event2, message: (_b = (_a = event2 == null ? void 0 : event2.target) == null ? void 0 : _a.error) == null ? void 0 : _b.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);
+              });
+            }
+          });
+        };
+      }),
+      "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;
   }
   /**
     * 添加数据到指定的存储对象
@@ -111,201 +195,215 @@ 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()}`;
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        if (log) {
-          this.app.logger.addLog({
-            type: "info",
-            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: "info",
-            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: "info",
-            title: uuid,
-            metadata: { msg: "事务错误" }
-          });
-        }
-        return reject(transaction.error ?? new Error("事务错误"));
-      };
-      transaction.onabort = (e) => {
-        if (log) {
-          this.app.logger.addLog({
-            type: "info",
-            title: uuid,
-            metadata: { msg: "事务被中止" }
-          });
-        }
-        return reject(new Error("事务被中止"));
-      };
-    });
-  }
-  /**
-   * 快速检查指定存储对象中的数据是否存在
-   * @param {string} storeName - 存储对象名称
-   * @param {string|number} key - 数据主键
-   * @returns {Promise<boolean>} 数据是否存在
-   */
-  async exists(storeName, key) {
-    if (!this.useIndexDB) {
-      const storageKey = this.getStorageKey(storeName, key);
-      return this.app.storage.getStorage(storageKey) !== 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 request = store.count(key);
-      request.onsuccess = () => resolve(request.result > 0);
-      request.onerror = () => reject(new Error("检查数据存在性失败"));
-    });
-  }
-  /**
-   * 获取指定存储对象中的数据
-   * @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) {
       this.app.logger.addLog({
         type: "info",
         title: uuid,
-        metadata: { msg: "获取数据前" }
+        metadata: { msg: "添加数据前", data }
       });
     }
-    if (!this.useIndexDB) {
-      const storageKey = this.getStorageKey(storeName, key);
-      let data = this.app.storage.getStorage(storageKey);
-      if (data) {
-        data = JSON.parse(data);
-      }
-      return data;
-    }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        if (log) {
-          this.app.logger.addLog({
-            type: "info",
-            title: uuid,
-            metadata: { msg: "数据库未连接" }
-          });
+    return this.withTimeout(
+      new Promise((resolve, reject) => {
+        if (!this.db) {
+          if (log) {
+            this.app.logger.addLog({
+              type: "error",
+              title: uuid,
+              metadata: { msg: "添加数据前 数据库未连接", data }
+            });
+          }
+          reject(new Error("数据库未连接"));
+          return;
         }
-        reject(new Error("数据库未连接"));
-        return;
-      }
-      let resolved = false;
-      try {
-        const transaction = this.db.transaction(storeName, "readonly");
+        const transaction = this.db.transaction(storeName, "readwrite");
         const store = transaction.objectStore(storeName);
-        const request = store.get(key);
+        const request = store.add(data);
         request.onsuccess = () => {
-          resolved = true;
           if (log) {
             this.app.logger.addLog({
               type: "info",
               title: uuid,
-              metadata: { msg: "获取成功" }
+              metadata: { msg: "添加数据成功" }
             });
           }
-          resolve(request.result ?? null);
+          return resolve(data);
         };
         request.onerror = () => {
-          resolved = true;
           if (log) {
             this.app.logger.addLog({
-              type: "info",
+              type: "error",
               title: uuid,
-              metadata: { msg: "获取失败" }
+              metadata: { msg: "添加数据失败" }
             });
           }
-          reject(request.error ?? new Error("获取数据失败"));
+          return reject(new Error("添加数据失败"));
         };
-        transaction.onabort = () => {
+        transaction.oncomplete = () => {
+          console.log("✅ 添加事务完成");
           if (log) {
             this.app.logger.addLog({
               type: "info",
               title: uuid,
-              metadata: { msg: "事务被中止" }
+              metadata: { msg: "事务完成" }
             });
           }
-          if (!resolved) reject(new Error("事务被中止"));
+          return;
         };
-        transaction.onerror = (event) => {
+        transaction.onerror = (e) => {
           if (log) {
             this.app.logger.addLog({
-              type: "info",
+              type: "error",
               title: uuid,
-              metadata: { msg: `事务错误: ${event.target.error}` }
+              metadata: { msg: "事务错误" }
             });
           }
-          if (!resolved) reject(new Error(`事务错误: ${event.target.error}`));
+          return reject(transaction.error ?? new Error("事务错误"));
         };
-        transaction.oncomplete = () => {
+        transaction.onabort = (e) => {
           if (log) {
             this.app.logger.addLog({
-              type: "info",
+              type: "error",
               title: uuid,
-              metadata: { msg: "事务完成" }
+              metadata: { msg: "事务被中止" }
             });
           }
+          return reject(new Error("事务被中止"));
         };
-      } catch (e) {
-        reject(e);
-      }
-    });
+      }),
+      `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(
+      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("检查数据存在性失败"));
+      }),
+      `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) {
+      this.app.logger.addLog({
+        type: "info",
+        title: uuid,
+        metadata: { msg: "获取数据前" }
+      });
+    }
+    if (!this.useIndexDB) {
+      const memStore = this.getMemoryStore(storeName);
+      return memStore.get(key) ?? null;
+    }
+    return this.withTimeout(
+      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;
+            if (log) {
+              this.app.logger.addLog({
+                type: "error",
+                title: uuid,
+                metadata: { msg: "获取失败" }
+              });
+            }
+            reject(request.error ?? new Error("获取数据失败"));
+          };
+          transaction.onabort = () => {
+            if (log) {
+              this.app.logger.addLog({
+                type: "info",
+                title: uuid,
+                metadata: { msg: "事务被中止" }
+              });
+            }
+            if (!resolved) reject(new Error("事务被中止"));
+          };
+          transaction.onerror = (event) => {
+            if (log) {
+              this.app.logger.addLog({
+                type: "error",
+                title: uuid,
+                metadata: { msg: `事务错误: ${event.target.error}` }
+              });
+            }
+            if (!resolved) reject(new Error(`事务错误: ${event.target.error}`));
+          };
+          transaction.oncomplete = () => {
+            if (log) {
+              this.app.logger.addLog({
+                type: "info",
+                title: uuid,
+                metadata: { msg: "事务完成" }
+              });
+            }
+          };
+        } catch (e) {
+          reject(e);
+        }
+      }),
+      `get(${storeName})`
+    );
   }
   /**
    * 更新指定存储对象中的数据
@@ -316,10 +414,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()}`;
@@ -330,76 +430,79 @@ var IndexDBManager = class _IndexDBManager {
         metadata: { msg: "更新数据前", data }
       });
     }
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        if (log) {
-          this.app.logger.addLog({
-            type: "info",
-            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 = () => {
-          if (log) {
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "数据更新失败" }
-            });
-          }
-          return reject(request.error ?? new Error("更新数据失败"));
-        };
-        transaction.oncomplete = () => {
-          if (log) {
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "事务完成" }
-            });
-          }
-          return console.log("✅ 事务完成");
-        };
-        transaction.onabort = (e) => {
+    return this.withTimeout(
+      new Promise((resolve, reject) => {
+        if (!this.db) {
           if (log) {
             this.app.logger.addLog({
-              type: "info",
+              type: "error",
               title: uuid,
-              metadata: { msg: "事务被中止" }
-            });
-          }
-          return reject(new Error("事务被中止"));
-        };
-        transaction.onerror = (e) => {
-          if (log) {
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "事务错误" }
+              metadata: { msg: "数据库未连接" }
             });
           }
-          return reject(transaction.error ?? new Error("事务错误"));
-        };
-      } catch (e) {
-        reject(e);
-      }
-    });
+          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 = () => {
+            if (log) {
+              this.app.logger.addLog({
+                type: "error",
+                title: uuid,
+                metadata: { msg: "数据更新失败" }
+              });
+            }
+            return reject(request.error ?? new Error("更新数据失败"));
+          };
+          transaction.oncomplete = () => {
+            if (log) {
+              this.app.logger.addLog({
+                type: "info",
+                title: uuid,
+                metadata: { msg: "事务完成" }
+              });
+            }
+            return console.log("✅ 事务完成");
+          };
+          transaction.onabort = (e) => {
+            if (log) {
+              this.app.logger.addLog({
+                type: "error",
+                title: uuid,
+                metadata: { msg: "事务被中止" }
+              });
+            }
+            return reject(new Error("事务被中止"));
+          };
+          transaction.onerror = (e) => {
+            if (log) {
+              this.app.logger.addLog({
+                type: "error",
+                title: uuid,
+                metadata: { msg: "事务错误" }
+              });
+            }
+            return reject(transaction.error ?? new Error("事务错误"));
+          };
+        } catch (e) {
+          reject(e);
+        }
+      }),
+      `update(${storeName})`
+    );
   }
   /**
    * 删除指定存储对象中的数据
@@ -409,21 +512,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(
+      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("删除数据失败"));
+      }),
+      `delete(${storeName})`
+    );
   }
   /**
    * 通过索引获取数据
@@ -442,18 +547,21 @@ 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(
+      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("通过索引获取数据失败"));
+      }),
+      `getByIndex(${storeName}, ${indexName})`
+    );
   }
   /**
    * 通过索引检查数据是否存在
@@ -471,18 +579,21 @@ 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(
+      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("通过索引检查数据存在性失败"));
+      }),
+      `existsByIndex(${storeName}, ${indexName})`
+    );
   }
   /**
    * 通过索引获取多条数据
@@ -501,18 +612,21 @@ 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(
+      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("通过索引获取多条数据失败"));
+      }),
+      `getAllByIndex(${storeName}, ${indexName})`
+    );
   }
   /**
    * 统计指定存储对象中的数据数量
@@ -524,17 +638,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(
+      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("统计数据数量失败"));
+      }),
+      `count(${storeName})`
+    );
   }
   /**
    * 通过索引统计数据数量
@@ -548,18 +665,21 @@ 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(
+      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("通过索引统计数据数量失败"));
+      }),
+      `countByIndex(${storeName}, ${indexName})`
+    );
   }
   /**
    * 获取指定存储对象中的所有数据
@@ -569,33 +689,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(
+      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("获取所有数据失败"));
+      }),
+      `getAll(${storeName})`
+    );
   }
   /**
    * 清空指定存储对象中的所有数据
@@ -604,28 +714,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(
+      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("清空数据失败"));
+      }),
+      `clear(${storeName})`
+    );
   }
   /**
    * 关闭数据库连接
@@ -639,10 +745,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;