@keq-request/cache 5.0.0-alpha.10

package/dist/index.js

@@ -0,0 +1,1102 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CacheStorage: () => KeqCacheStorage,
+  Eviction: () => Eviction,
+  IndexedDBStorage: () => IndexedDBStorage,
+  MemoryStorage: () => MemoryStorage,
+  Strategy: () => Strategy,
+  TierStorage: () => TierStorage,
+  cache: () => cache
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cache.ts
+var R = __toESM(require("ramda"));
+var import_keq = require("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 import_keq.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
+var import_dayjs2 = __toESM(require("dayjs"));
+var R3 = __toESM(require("ramda"));
+
+// src/storage/memory-storage/base-memory-storage.ts
+var import_dayjs = __toESM(require("dayjs"));
+var R2 = __toESM(require("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 = (0, import_dayjs.default)();
+  /**
+   * @zh 清除过期的缓存
+   */
+  evictExpired() {
+    const now = (0, import_dayjs.default)();
+    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 = (0, import_dayjs2.default)(a.expiredAt);
+      const bExpiredAt = (0, import_dayjs2.default)(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
+var import_dayjs3 = __toESM(require("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 (0, import_dayjs3.default)(aVisitAt).isBefore((0, import_dayjs3.default)(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
+var R5 = __toESM(require("ramda"));
+
+// src/storage/indexed-db-storage/base-indexed-db-storage.ts
+var R4 = __toESM(require("ramda"));
+var import_idb = require("idb");
+var import_dayjs4 = __toESM(require("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 (0, import_idb.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 = (0, import_dayjs4.default)();
+  /**
+   * @zh 清除过期的缓存
+   */
+  async evictExpired() {
+    const now = (0, import_dayjs4.default)();
+    if (now.diff(this.lastEvictExpiredTime, "second") < 1) return;
+    try {
+      const now2 = (0, import_dayjs4.default)();
+      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 ((0, import_dayjs4.default)(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]
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheStorage,
+  Eviction,
+  IndexedDBStorage,
+  MemoryStorage,
+  Strategy,
+  TierStorage,
+  cache
+});
+//# sourceMappingURL=index.js.map