@keq-request/cache 5.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,1059 @@
+// src/cache.ts
+import * as R from "ramda";
+import { Exception } from "keq";
+function cache(opts) {
+  const storage = opts.storage;
+  const rules = opts?.rules || [];
+  return async function cache2(ctx, next) {
+    let cOpt = ctx.options.cache;
+    const rule = rules.find((rule2) => {
+      if (rule2.pattern === void 0 || rule2.pattern === true) return true;
+      if (typeof rule2.pattern === "function") return rule2.pattern(ctx);
+      return rule2.pattern.test(ctx.request.__url__.href);
+    });
+    if (rule) cOpt = R.mergeRight(rule, cOpt || {});
+    if (!cOpt || R.isEmpty(cOpt)) {
+      await next();
+      return;
+    }
+    let key = ctx.locationId;
+    if (cOpt.key) {
+      if (typeof cOpt.key === "function") key = cOpt.key(ctx);
+      else key = cOpt.key;
+    } else if (opts?.keyFactory) {
+      key = opts.keyFactory(ctx);
+    }
+    if (!key) throw new Exception("Cache key is required");
+    const strategy = cOpt.strategy;
+    const opt = {
+      key,
+      storage,
+      ttl: cOpt.ttl,
+      exclude: cOpt.exclude
+    };
+    await strategy(opt)(ctx, next);
+  };
+}
+
+// src/utils/get-response-bytes.ts
+async function getResponseBytes(response) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength) {
+    return parseInt(contentLength);
+  }
+  const arrayBuffer = await response.clone().arrayBuffer();
+  return arrayBuffer.byteLength;
+}
+
+// src/cache-entry/cache-entry.ts
+var CacheEntry = class _CacheEntry {
+  key;
+  response;
+  /**
+   * @en bytes
+   * @zh 字节数
+   */
+  size;
+  expiredAt;
+  constructor(options) {
+    this.key = options.key;
+    this.response = options.response;
+    this.size = options.size;
+    this.expiredAt = options.expiredAt ?? /* @__PURE__ */ new Date(864e13);
+  }
+  static async build(options) {
+    const expiredAt = "expiredAt" in options ? options.expiredAt : "ttl" in options && typeof options.ttl === "number" && options.ttl > 0 ? new Date(Date.now() + options.ttl * 1e3) : /* @__PURE__ */ new Date(864e13);
+    const response = options.response.clone();
+    return new _CacheEntry({
+      key: options.key,
+      response,
+      size: options.size ?? await getResponseBytes(response),
+      expiredAt
+    });
+  }
+  clone() {
+    return new _CacheEntry({
+      key: this.key,
+      response: this.response.clone(),
+      size: this.size,
+      expiredAt: this.expiredAt
+    });
+  }
+  assign(another) {
+    this.key = another.key;
+    this.response = another.response.clone();
+    this.size = another.size;
+    this.expiredAt = another.expiredAt;
+    return this;
+  }
+};
+
+// src/strategies/utils/cache-context.ts
+async function cacheContext(opts, context) {
+  if (!context.response) return;
+  if (opts.exclude && await opts.exclude(context.response)) return;
+  const key = opts.key;
+  const storage = opts.storage;
+  const entry = await CacheEntry.build({
+    key,
+    response: context.response,
+    ttl: opts.ttl
+  });
+  storage.set(entry);
+  return entry;
+}
+
+// src/strategies/cache-first.ts
+var cacheFirst = function(opts) {
+  const { storage, key } = opts;
+  return async function(context, next) {
+    const cache2 = await storage.get(key);
+    if (cache2) {
+      context.emitter.emit("cache:hit", { key, response: cache2.response, context });
+      context.res = cache2.response;
+      return;
+    }
+    context.emitter.emit("cache:miss", { key, context });
+    await next();
+    const entry = await cacheContext(opts, context);
+    if (entry) {
+      context.emitter.emit("cache:update", {
+        key,
+        oldResponse: void 0,
+        newResponse: entry.response,
+        context
+      });
+    }
+  };
+};
+
+// src/strategies/network-first.ts
+var networkFirst = function(opts) {
+  const { key, storage } = opts;
+  return async function(context, next) {
+    try {
+      await next();
+      const cache2 = await storage.get(key);
+      const entry = await cacheContext(opts, context);
+      if (entry) {
+        context.emitter.emit("cache:update", {
+          key,
+          oldResponse: cache2?.response,
+          newResponse: entry.response,
+          context
+        });
+      }
+    } catch (err) {
+      const cache2 = await storage.get(key);
+      if (!cache2) {
+        context.emitter.emit("cache:miss", { key, context });
+        throw err;
+      }
+      context.emitter.emit("cache:hit", { key, response: cache2.response, context });
+      context.res = cache2.response;
+    }
+  };
+};
+
+// src/strategies/network-only.ts
+var networkOnly = function(opts) {
+  return async function(ctx, next) {
+    await next();
+  };
+};
+
+// src/strategies/stale-while-revalidate.ts
+var staleWhileRevalidate = function(opts) {
+  const { key, storage } = opts;
+  return async function(context, next) {
+    const cache2 = await storage.get(key);
+    if (cache2) {
+      context.emitter.emit("cache:hit", { key, response: cache2.response, context });
+      const orchestrator = context.orchestration.fork();
+      context.res = cache2.response;
+      setTimeout(async () => {
+        try {
+          await orchestrator.execute();
+          const context2 = orchestrator.context;
+          const entry = await cacheContext(opts, context2);
+          if (entry) {
+            context2.emitter.emit("cache:update", {
+              key,
+              oldResponse: cache2.response,
+              newResponse: entry.response,
+              context: context2
+            });
+          }
+        } catch (err) {
+        }
+      }, 1);
+    } else {
+      context.emitter.emit("cache:miss", { key, context });
+      await next();
+      const entry = await cacheContext(opts, context);
+      if (entry) {
+        context.emitter.emit("cache:update", {
+          key,
+          oldResponse: void 0,
+          newResponse: entry.response,
+          context
+        });
+      }
+    }
+  };
+};
+
+// src/constants/strategy.enum.ts
+var Strategy = {
+  STALE_WHILE_REVALIDATE: staleWhileRevalidate,
+  NETWORK_FIRST: networkFirst,
+  NETWORK_ONLY: networkOnly,
+  CACHE_FIRST: cacheFirst
+};
+
+// src/constants/eviction.enum.ts
+var Eviction = /* @__PURE__ */ ((Eviction2) => {
+  Eviction2["LRU"] = "lru";
+  Eviction2["LFU"] = "lfu";
+  Eviction2["RANDOM"] = "random";
+  Eviction2["TTL"] = "ttl";
+  return Eviction2;
+})(Eviction || {});
+
+// src/storage/memory-storage/ttl-memory-storage.ts
+import dayjs2 from "dayjs";
+import * as R3 from "ramda";
+
+// src/storage/memory-storage/base-memory-storage.ts
+import dayjs from "dayjs";
+import * as R2 from "ramda";
+
+// src/utils/debug.ts
+function debug(...args) {
+  console.debug("[@keq-cache] [DEBUG] ", ...args);
+}
+
+// src/storage/keq-cache-storage.ts
+var KeqCacheStorage = class {
+};
+
+// src/storage/internal-storage/internal-storage.ts
+var InternalStorage = class extends KeqCacheStorage {
+  __id__ = Math.random().toString(36).slice(2);
+  __size__;
+  __debug__;
+  __onCacheGet__;
+  __onCacheSet__;
+  __onCacheRemove__;
+  __onCacheEvict__;
+  __onCacheExpired__;
+  constructor(options) {
+    super();
+    if (options?.size && (typeof options?.size !== "number" || options.size <= 0)) {
+      throw TypeError(`Invalid size: ${String(options?.size)}`);
+    }
+    this.__size__ = options?.size ?? Infinity;
+    this.__debug__ = !!options?.debug;
+    this.__onCacheGet__ = options?.onCacheGet;
+    this.__onCacheSet__ = options?.onCacheSet;
+    this.__onCacheRemove__ = options?.onCacheRemove;
+    this.__onCacheEvict__ = options?.onCacheEvict;
+    this.debug((log) => log("Storage Created: ", this));
+  }
+  debug(fn) {
+    if (this.__debug__) {
+      fn((...args) => {
+        debug(`[Storage(${this.__id__})]`, ...args);
+      });
+    }
+  }
+};
+
+// src/storage/memory-storage/base-memory-storage.ts
+var BaseMemoryStorage = class extends InternalStorage {
+  storage = /* @__PURE__ */ new Map();
+  visitTimeRecords = /* @__PURE__ */ new Map();
+  visitCountRecords = /* @__PURE__ */ new Map();
+  get size() {
+    const used = R2.sum(R2.pluck("size", [...this.storage.values()]));
+    const free = this.__size__ > used ? this.__size__ - used : 0;
+    return {
+      used,
+      free
+    };
+  }
+  get(key) {
+    this.evictExpired();
+    const entry = this.storage.get(key);
+    this.visitCountRecords.set(key, (this.visitCountRecords.get(key) ?? 0) + 1);
+    this.visitTimeRecords.set(key, /* @__PURE__ */ new Date());
+    if (!entry) this.debug((log) => log(`Entry(${key}) Not Found`));
+    else this.debug((log) => log(`Entry(${key}) Found: `, entry));
+    return entry?.clone();
+  }
+  set(value) {
+    if (!this.evict(value.size)) {
+      this.debug((log) => log("Storage Size Not Enough: ", this.size.free, " < ", value.size));
+      return;
+    }
+    this.storage.set(value.key, value);
+    this.visitTimeRecords.set(value.key, /* @__PURE__ */ new Date());
+    this.visitCountRecords.set(value.key, this.visitCountRecords.get(value.key) ?? 0);
+    this.debug((log) => log("Entry Added: ", value));
+    this.debug((log) => log("Storage Size: ", this.size));
+  }
+  __remove__(keys) {
+    for (const key of keys) {
+      const entry = this.storage.get(key);
+      if (!entry) return;
+      this.storage.delete(key);
+      this.visitCountRecords.delete(key);
+      this.visitTimeRecords.delete(key);
+      this.debug((log) => log("Entry Removed: ", entry));
+      this.debug((log) => log("Storage Size: ", this.size));
+    }
+  }
+  remove(key) {
+    this.__remove__([key]);
+  }
+  lastEvictExpiredTime = dayjs();
+  /**
+   * @zh 清除过期的缓存
+   */
+  evictExpired() {
+    const now = dayjs();
+    if (now.diff(this.lastEvictExpiredTime, "second") < 1) return;
+    const keys = [];
+    for (const [key, entry] of this.storage.entries()) {
+      if (entry.expiredAt && now.isAfter(entry.expiredAt)) {
+        keys.push(key);
+      }
+    }
+    this.__remove__(keys);
+    this.__onCacheExpired__?.({ keys });
+  }
+  /**
+   * @en Evict the storage to make sure the size is enough
+   * @zh 清除缓存以确保有足够的空间
+   *
+   * @return {boolean} - is evicted successfully
+   */
+  evict(expectSize) {
+    this.evictExpired();
+    const size = this.size;
+    return size.free >= expectSize;
+  }
+};
+
+// src/storage/memory-storage/ttl-memory-storage.ts
+var TTLMemoryStorage = class extends BaseMemoryStorage {
+  constructor(options) {
+    super(options);
+  }
+  get(key) {
+    const entry = super.get(key);
+    this.__onCacheGet__?.({ key });
+    return entry;
+  }
+  set(value) {
+    super.set(value);
+    this.__onCacheSet__?.({ key: value.key });
+  }
+  remove(key) {
+    super.remove(key);
+    this.__onCacheRemove__?.({ key });
+  }
+  evict(expectSize) {
+    if (expectSize > this.__size__) {
+      this.debug((log) => log("Storage Size Not Enough: ", this.__size__, " < ", expectSize));
+      return false;
+    }
+    this.evictExpired();
+    let deficitSize = expectSize - this.size.free;
+    if (deficitSize <= 0) return true;
+    const entries = [...this.storage.values()].sort((a, b) => {
+      const aExpiredAt = dayjs2(a.expiredAt);
+      const bExpiredAt = dayjs2(b.expiredAt);
+      return aExpiredAt.isBefore(bExpiredAt) ? 1 : -1;
+    });
+    if (R3.sum(R3.pluck("size", entries)) < deficitSize) {
+      this.debug((log) => log("Storage Size Not Enough: ", this.size.free, " < ", deficitSize));
+      return false;
+    }
+    const keys = [];
+    while (deficitSize > 0 && entries.length) {
+      const entry = entries.pop();
+      deficitSize -= entry.size;
+      keys.push(entry.key);
+    }
+    this.__remove__(keys);
+    this.__onCacheEvict__?.({ keys });
+    return true;
+  }
+};
+
+// src/utils/random.ts
+function random(min, max) {
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+
+// src/storage/memory-storage/random-memory-storage.ts
+var RandomMemoryStorage = class extends BaseMemoryStorage {
+  constructor(options) {
+    super(options);
+  }
+  get(key) {
+    const entry = super.get(key);
+    this.__onCacheGet__?.({ key });
+    return entry;
+  }
+  set(value) {
+    super.set(value);
+    this.__onCacheSet__?.({ key: value.key });
+  }
+  remove(key) {
+    super.remove(key);
+    this.__onCacheRemove__?.({ key });
+  }
+  evict(expectSize) {
+    if (expectSize > this.__size__) {
+      this.debug((log) => log("Storage Size Not Enough: ", this.__size__, " < ", expectSize));
+      return false;
+    }
+    this.evictExpired();
+    let deficitSize = expectSize - this.size.free;
+    if (deficitSize <= 0) return true;
+    const entries = [...this.storage.values()];
+    const keys = [];
+    while (deficitSize > 0 && entries.length) {
+      const index = random(0, entries.length - 1);
+      const entry = entries[index];
+      deficitSize -= entry.size;
+      entries.splice(index, 1);
+      keys.push(entry.key);
+    }
+    this.__remove__(keys);
+    this.__onCacheEvict__?.({ keys });
+    return true;
+  }
+};
+
+// src/storage/memory-storage/lru-memory-storage.ts
+import dayjs3 from "dayjs";
+var LRUMemoryStorage = class extends BaseMemoryStorage {
+  constructor(options) {
+    super(options);
+  }
+  get(key) {
+    const entry = super.get(key);
+    this.__onCacheGet__?.({ key });
+    return entry;
+  }
+  set(value) {
+    super.set(value);
+    this.__onCacheSet__?.({ key: value.key });
+  }
+  remove(key) {
+    super.remove(key);
+    this.__onCacheRemove__?.({ key });
+  }
+  evict(expectSize) {
+    if (expectSize > this.__size__) {
+      this.debug((log) => log("Storage Size Not Enough: ", this.__size__, " < ", expectSize));
+      return false;
+    }
+    this.evictExpired();
+    let deficitSize = expectSize - this.size.free;
+    if (deficitSize <= 0) return true;
+    const entries = [...this.storage.values()].sort((a, b) => {
+      const aVisitAt = this.visitTimeRecords.get(a.key);
+      const bVisitAt = this.visitTimeRecords.get(b.key);
+      if (aVisitAt === bVisitAt) return 0;
+      if (!aVisitAt) return 1;
+      if (!bVisitAt) return -1;
+      return dayjs3(aVisitAt).isBefore(dayjs3(bVisitAt)) ? 1 : -1;
+    });
+    const keys = [];
+    while (deficitSize > 0 && entries.length) {
+      const entry = entries.pop();
+      deficitSize -= entry.size;
+      keys.push(entry.key);
+    }
+    this.__remove__(keys);
+    this.__onCacheEvict__?.({ keys });
+    return true;
+  }
+};
+
+// src/storage/memory-storage/lfu-memory-storage.ts
+var LFUMemoryStorage = class extends BaseMemoryStorage {
+  constructor(options) {
+    super(options);
+  }
+  get(key) {
+    const entry = super.get(key);
+    this.__onCacheGet__?.({ key });
+    return entry;
+  }
+  set(value) {
+    super.set(value);
+    this.__onCacheSet__?.({ key: value.key });
+  }
+  remove(key) {
+    super.remove(key);
+    this.__onCacheRemove__?.({ key });
+  }
+  evict(expectSize) {
+    if (expectSize > this.__size__) {
+      this.debug((log) => log("Storage Size Not Enough: ", this.__size__, " < ", expectSize));
+      return false;
+    }
+    this.evictExpired();
+    let deficitSize = expectSize - this.size.free;
+    if (deficitSize <= 0) return true;
+    const entries = [...this.storage.values()].sort((a, b) => {
+      const aVisitCount = this.visitCountRecords.get(a.key) || 0;
+      const bVisitCount = this.visitCountRecords.get(b.key) || 0;
+      return bVisitCount - aVisitCount;
+    });
+    const keys = [];
+    while (deficitSize > 0 && entries.length) {
+      const entry = entries.pop();
+      deficitSize -= entry.size;
+      keys.push(entry.key);
+    }
+    this.__remove__(keys);
+    this.__onCacheEvict__?.({ keys });
+    return true;
+  }
+};
+
+// src/storage/memory-storage/memory-storage.ts
+var MemoryStorage = class extends KeqCacheStorage {
+  storage;
+  constructor(options) {
+    super();
+    const eviction = options?.eviction || "lru" /* LRU */;
+    if (eviction === "ttl" /* TTL */) {
+      this.storage = new TTLMemoryStorage(options);
+    } else if (eviction === "random" /* RANDOM */) {
+      this.storage = new RandomMemoryStorage(options);
+    } else if (eviction === "lru" /* LRU */) {
+      this.storage = new LRUMemoryStorage(options);
+    } else if (eviction === "lfu" /* LFU */) {
+      this.storage = new LFUMemoryStorage(options);
+    } else {
+      throw new TypeError(`Invalid eviction: ${String(eviction)}`);
+    }
+  }
+  set(entry) {
+    return this.storage.set(entry);
+  }
+  get(key) {
+    return this.storage.get(key);
+  }
+  remove(key) {
+    return this.storage.remove(key);
+  }
+};
+
+// src/storage/indexed-db-storage/random-indexed-db-storage.ts
+import * as R5 from "ramda";
+
+// src/storage/indexed-db-storage/base-indexed-db-storage.ts
+import * as R4 from "ramda";
+import { openDB } from "idb";
+import dayjs4 from "dayjs";
+
+// src/storage/indexed-db-storage/constants/default-table-name.ts
+var DEFAULT_TABLE_NAME = "keq_cache_indexed_db_storage";
+
+// src/storage/indexed-db-storage/base-indexed-db-storage.ts
+var BaseIndexedDBStorage = class extends InternalStorage {
+  tableName = DEFAULT_TABLE_NAME;
+  db;
+  constructor(options) {
+    super(options);
+    if (options?.tableName === DEFAULT_TABLE_NAME) {
+      throw new TypeError(`[keq-cache] IndexedDBStorage name cannot be "${DEFAULT_TABLE_NAME}"`);
+    }
+    this.tableName = options?.tableName || DEFAULT_TABLE_NAME;
+  }
+  async openDB() {
+    if (this.db) return this.db;
+    const tableName = this.tableName;
+    const db = await openDB(tableName, 2, {
+      upgrade(db2) {
+        if (!db2.objectStoreNames.contains("metadata")) {
+          const entriesStore = db2.createObjectStore("metadata", { keyPath: "key" });
+          entriesStore.createIndex("expiredAt", "expiredAt");
+        }
+        if (!db2.objectStoreNames.contains("response")) {
+          const responsesStore = db2.createObjectStore("response", { keyPath: "key" });
+          responsesStore.createIndex("responseStatus", "responseStatus");
+        }
+        if (!db2.objectStoreNames.contains("visits")) {
+          const visitsStore = db2.createObjectStore("visits", { keyPath: "key" });
+          visitsStore.createIndex("visitCount", "visitCount");
+          visitsStore.createIndex("lastVisitedAt", "lastVisitedAt");
+        }
+      },
+      blocked() {
+        console.error(`IndexedDB Table ${tableName} is blocked`);
+      },
+      blocking() {
+        console.error(`IndexedDB Table ${tableName} is blocking`);
+      },
+      terminated() {
+        console.error(`IndexedDB Table ${tableName} is terminated`);
+      }
+    });
+    this.db = db;
+    return db;
+  }
+  async getSize() {
+    const db = await this.openDB();
+    const items = await db.getAll("metadata");
+    const used = R4.sum(items.map((entry) => entry.size));
+    const free = this.__size__ - used;
+    return { used, free };
+  }
+  async get(key) {
+    await this.evictExpired();
+    try {
+      const db = await this.openDB();
+      const dbMetadata = await db.get("metadata", key);
+      const dbResponse = await db.get("response", key);
+      const dbVisits = await db.get("visits", key);
+      if (!dbMetadata || !dbResponse) return;
+      await db.put("visits", {
+        key: dbMetadata.key,
+        visitCount: dbVisits ? dbVisits.visitCount + 1 : 1,
+        lastVisitedAt: /* @__PURE__ */ new Date()
+      });
+      const response = new Response(dbResponse.responseBody, {
+        status: dbResponse.responseStatus,
+        headers: new Headers(dbResponse.responseHeaders),
+        statusText: dbResponse.responseStatusText
+      });
+      return await CacheEntry.build({
+        key: dbMetadata.key,
+        expiredAt: dbMetadata.expiredAt,
+        response,
+        size: dbMetadata.size
+      });
+    } catch (error) {
+      return;
+    }
+  }
+  async set(entry) {
+    try {
+      if (!await this.evict(entry.size)) {
+        const size = await this.getSize();
+        this.debug((log) => log(`Storage Size Not Enough: ${size.free} < ${entry.size}`));
+        return;
+      }
+      const dbMetadata = {
+        key: entry.key,
+        size: entry.size,
+        expiredAt: entry.expiredAt,
+        visitedAt: /* @__PURE__ */ new Date(),
+        visitCount: 0
+      };
+      const response = entry.response.clone();
+      const dbResponse = {
+        key: entry.key,
+        responseBody: await response.arrayBuffer(),
+        responseHeaders: [...response.headers.entries()],
+        responseStatus: response.status,
+        responseStatusText: response.statusText
+      };
+      const db = await this.openDB();
+      const tx = db.transaction(["metadata", "response", "visits"], "readwrite");
+      const metadataStore = await tx.objectStore("metadata");
+      const responseStore = await tx.objectStore("response");
+      const visitsStore = await tx.objectStore("visits");
+      const dbVisits = await visitsStore.get(entry.key) || {
+        key: entry.key,
+        visitCount: 0,
+        lastVisitedAt: /* @__PURE__ */ new Date()
+      };
+      await Promise.all([
+        metadataStore.put(dbMetadata),
+        responseStore.put(dbResponse),
+        visitsStore.put(dbVisits)
+      ]);
+      await tx.done;
+    } catch (error) {
+      return;
+    }
+  }
+  async __remove__(tx, keys) {
+    await Promise.all(
+      R4.unnest(
+        keys.map((key) => [
+          tx.objectStore("metadata").delete(key),
+          tx.objectStore("response").delete(key),
+          tx.objectStore("visits").delete(key)
+        ])
+      )
+    );
+  }
+  async remove(key) {
+    try {
+      const db = await this.openDB();
+      const tx = db.transaction(["metadata", "response", "visits"], "readwrite");
+      await this.__remove__(tx, [key]);
+      await tx.done;
+    } catch (error) {
+      return;
+    }
+  }
+  lastEvictExpiredTime = dayjs4();
+  /**
+   * @zh 清除过期的缓存
+   */
+  async evictExpired() {
+    const now = dayjs4();
+    if (now.diff(this.lastEvictExpiredTime, "second") < 1) return;
+    try {
+      const now2 = dayjs4();
+      const db = await this.openDB();
+      const tx = db.transaction(["metadata", "response", "visits"], "readwrite");
+      const metadataStore = tx.objectStore("metadata");
+      let cursor = await metadataStore.index("expiredAt").openCursor(IDBKeyRange.upperBound(now2.valueOf()));
+      const expiredKeys = [];
+      while (cursor) {
+        if (dayjs4(cursor.value.expiredAt).isBefore(now2)) {
+          expiredKeys.push(cursor.value.key);
+          cursor = await cursor.continue();
+        } else {
+          break;
+        }
+      }
+      await this.__remove__(tx, expiredKeys);
+      await tx.done;
+      this.__onCacheExpired__?.({ keys: expiredKeys });
+    } catch (error) {
+      return;
+    }
+  }
+};
+
+// src/storage/indexed-db-storage/random-indexed-db-storage.ts
+var RandomIndexedDBStorage = class extends BaseIndexedDBStorage {
+  constructor(options) {
+    super(options);
+  }
+  async get(key) {
+    const entry = await super.get(key);
+    this.__onCacheGet__?.({ key });
+    return entry;
+  }
+  async set(value) {
+    await super.set(value);
+    this.__onCacheSet__?.({ key: value.key });
+  }
+  async remove(key) {
+    await super.remove(key);
+    this.__onCacheRemove__?.({ key });
+  }
+  async evict(expectSize) {
+    await this.evictExpired();
+    const size = await this.getSize();
+    let deficitSize = expectSize - size.free;
+    if (deficitSize <= 0) return true;
+    const db = await this.openDB();
+    const tx = db.transaction(["metadata", "response", "visits"], "readwrite");
+    const metadataStore = tx.objectStore("metadata");
+    const metadatas = await metadataStore.getAll();
+    const totalSize = R5.sum(metadatas.map((m) => m.size));
+    if (totalSize < deficitSize) {
+      this.debug((log) => log(`Storage Size Not Enough, deficit size: ${deficitSize - totalSize}`));
+      await tx.abort();
+      return false;
+    }
+    const keys = [];
+    while (deficitSize > 0 && metadatas.length) {
+      const index = random(0, metadatas.length - 1);
+      const metadata = metadatas[index];
+      deficitSize -= metadata.size;
+      keys.push(metadata.key);
+      metadatas.splice(index, 1);
+    }
+    await this.__remove__(tx, keys);
+    await tx.done;
+    await this.__onCacheEvict__?.({ keys });
+    return true;
+  }
+};
+
+// src/storage/indexed-db-storage/lfu-indexed-db-storage.ts
+var LFUIndexedDBStorage = class extends BaseIndexedDBStorage {
+  constructor(options) {
+    super(options);
+  }
+  async get(key) {
+    const entry = await super.get(key);
+    this.__onCacheGet__?.({ key });
+    return entry;
+  }
+  async set(value) {
+    await super.set(value);
+    this.__onCacheSet__?.({ key: value.key });
+  }
+  async remove(key) {
+    await super.remove(key);
+    this.__onCacheRemove__?.({ key });
+  }
+  async evict(expectSize) {
+    await this.evictExpired();
+    const size = await this.getSize();
+    let deficitSize = expectSize - size.free;
+    if (deficitSize <= 0) return true;
+    const db = await this.openDB();
+    const tx = db.transaction(["metadata", "response", "visits"], "readwrite");
+    const metadataStore = tx.objectStore("metadata");
+    const visitsStore = tx.objectStore("visits");
+    let cursor = await visitsStore.index("visitCount").openCursor();
+    const keys = [];
+    while (deficitSize > 0 && cursor) {
+      const metadata = await metadataStore.get(cursor.value.key);
+      if (!metadata) {
+        await cursor.delete();
+        cursor = await cursor.continue();
+        continue;
+      }
+      deficitSize -= metadata.size;
+      keys.push(cursor.value.key);
+      cursor = await cursor.continue();
+    }
+    if (deficitSize > 0) {
+      this.debug((log) => log(`Storage Size Not Enough, deficit size: ${deficitSize}`));
+      await tx.abort;
+      return false;
+    }
+    await this.__remove__(tx, keys);
+    await tx.done;
+    this.__onCacheEvict__?.({ keys });
+    return true;
+  }
+};
+
+// src/storage/indexed-db-storage/lru-indexed-db-storage.ts
+var LRUIndexedDBStorage = class extends BaseIndexedDBStorage {
+  constructor(options) {
+    super(options);
+  }
+  async get(key) {
+    const entry = await super.get(key);
+    this.__onCacheGet__?.({ key });
+    return entry;
+  }
+  async set(value) {
+    await super.set(value);
+    this.__onCacheSet__?.({ key: value.key });
+  }
+  async remove(key) {
+    await super.remove(key);
+    this.__onCacheRemove__?.({ key });
+  }
+  async evict(expectSize) {
+    await this.evictExpired();
+    const size = await this.getSize();
+    let deficitSize = expectSize - size.free;
+    if (deficitSize <= 0) return true;
+    const db = await this.openDB();
+    const tx = db.transaction(["metadata", "response", "visits"], "readwrite");
+    const metadataStore = tx.objectStore("metadata");
+    const visitsStore = tx.objectStore("visits");
+    const keys = [];
+    let cursor = await visitsStore.index("lastVisitedAt").openCursor();
+    while (deficitSize > 0 && cursor) {
+      const metadata = await metadataStore.get(cursor.value.key);
+      if (!metadata) {
+        await cursor.delete();
+        cursor = await cursor.continue();
+        continue;
+      }
+      deficitSize -= metadata.size;
+      keys.push(cursor.value.key);
+      cursor = await cursor.continue();
+    }
+    if (deficitSize > 0) {
+      this.debug((log) => log(`Storage Size Not Enough, deficit size: ${deficitSize}`));
+      await tx.abort();
+      return false;
+    }
+    await this.__remove__(tx, keys);
+    await tx.done;
+    await this.__onCacheEvict__?.({ keys });
+    return true;
+  }
+};
+
+// src/storage/indexed-db-storage/ttl-indexed-db-storage.ts
+var TTLIndexedDBStorage = class extends BaseIndexedDBStorage {
+  constructor(options) {
+    super(options);
+  }
+  async get(key) {
+    const entry = await super.get(key);
+    this.__onCacheGet__?.({ key });
+    return entry;
+  }
+  async set(value) {
+    await super.set(value);
+    this.__onCacheSet__?.({ key: value.key });
+  }
+  async remove(key) {
+    await super.remove(key);
+    this.__onCacheRemove__?.({ key });
+  }
+  async evict(expectSize) {
+    await this.evictExpired();
+    const size = await this.getSize();
+    let deficitSize = expectSize - size.free;
+    if (deficitSize <= 0) return true;
+    const db = await this.openDB();
+    const tx = db.transaction(["metadata", "response", "visits"], "readwrite");
+    const metadataStore = tx.objectStore("metadata");
+    const keys = [];
+    let cursor = await metadataStore.index("expiredAt").openCursor();
+    while (deficitSize > 0 && cursor) {
+      const metadata = await metadataStore.get(cursor.value.key);
+      if (!metadata) {
+        await cursor.delete();
+        cursor = await cursor.continue();
+        continue;
+      }
+      deficitSize -= metadata.size;
+      keys.push(cursor.value.key);
+      cursor = await cursor.continue();
+    }
+    if (deficitSize > 0) {
+      this.debug((log) => log(`Storage Size Not Enough, deficit size: ${deficitSize}`));
+      await tx.abort();
+      return false;
+    }
+    await this.__remove__(tx, keys);
+    await tx.done;
+    await this.__onCacheEvict__?.({ keys });
+    return true;
+  }
+};
+
+// src/storage/indexed-db-storage/indexed-db-storage.ts
+var IndexedDBStorage = class extends KeqCacheStorage {
+  storage;
+  constructor(options) {
+    super();
+    const eviction = options?.eviction || "lru" /* LRU */;
+    if (eviction === "random" /* RANDOM */) {
+      this.storage = new RandomIndexedDBStorage(options);
+    } else if (eviction === "lfu" /* LFU */) {
+      this.storage = new LFUIndexedDBStorage(options);
+    } else if (eviction === "lru" /* LRU */) {
+      this.storage = new LRUIndexedDBStorage(options);
+    } else if (eviction === "ttl" /* TTL */) {
+      this.storage = new TTLIndexedDBStorage(options);
+    } else {
+      throw TypeError(`Not Supported Eviction: ${String(options?.eviction)}`);
+    }
+  }
+  set(entry) {
+    return this.storage.set(entry);
+  }
+  get(key) {
+    return this.storage.get(key);
+  }
+  remove(key) {
+    return this.storage.remove(key);
+  }
+};
+
+// src/storage/multi-tier-storage/multi-tier-storage.ts
+var MultiTierStorage = class extends KeqCacheStorage {
+  storages;
+  /**
+   * @param storages Array of storage instances ordered by performance (fastest first)
+   * @zh 按性价比排序的存储实例数组，排在前面的成本低，排在后面的成本高
+   */
+  constructor(options) {
+    super();
+    if (!options.tiers || options.tiers.length === 0) {
+      throw new Error("At least one storage instance is required");
+    }
+    this.storages = [...options.tiers];
+  }
+  /**
+   * @en Get cache entry, searching from lowest to highest tier
+   * @zh 获取缓存条目，从最底层到高层依次搜索
+   */
+  async get(key) {
+    for (let i = 0; i < this.storages.length; i++) {
+      const storage = this.storages[i];
+      const entry = await storage.get(key);
+      if (entry) {
+        if (i > 0) {
+          await this.syncToLowerTiers(entry, i);
+        }
+        return entry;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * @en Set cache entry to all tiers concurrently
+   * @zh 并发写入所有层的缓存
+   */
+  async set(entry) {
+    const promises = this.storages.map((storage) => storage.set(entry));
+    await Promise.all(promises);
+  }
+  /**
+   * @en Remove cache entry from all tiers
+   * @zh 从所有层删除缓存条目
+   */
+  async remove(key) {
+    const promises = this.storages.map((storage) => storage.remove(key));
+    await Promise.all(promises);
+  }
+  /**
+   * @en Sync cache entry to all lower tiers (tiers with index < currentTierIndex)
+   * @zh 将缓存条目同步到所有低层存储（索引小于当前层的存储）
+   */
+  async syncToLowerTiers(entry, currentTierIndex) {
+    const lowerTierStorages = this.storages.slice(0, currentTierIndex);
+    if (lowerTierStorages.length === 0) {
+      return;
+    }
+    const promises = lowerTierStorages.map((storage) => storage.set(entry.clone()));
+    try {
+      await Promise.all(promises);
+    } catch (error) {
+      console.warn("Failed to sync cache entry to lower tiers:", error);
+    }
+  }
+};
+
+// src/storage/tier-storage/tier-storage.ts
+var TierStorage = class extends MultiTierStorage {
+  constructor(options) {
+    const memoryStorage = options?.memory instanceof MemoryStorage ? options.memory : new MemoryStorage(options?.memory);
+    const indexedDBStorage = options?.indexedDB instanceof IndexedDBStorage ? options.indexedDB : new IndexedDBStorage(options?.indexedDB);
+    super({
+      tiers: [memoryStorage, indexedDBStorage]
+    });
+  }
+};
+export {
+  KeqCacheStorage as CacheStorage,
+  Eviction,
+  IndexedDBStorage,
+  MemoryStorage,
+  Strategy,
+  TierStorage,
+  cache
+};
+//# sourceMappingURL=index.mjs.map