cache-kit/dist/browser-GGUSVVA3.mjs

A simple caching layer for fetch requests — supports memory, browser (localStorage), and Node.js (filesystem) adapters with smart strategies.

import {
  getExpiryTimeCacheKey,
  makeKey
} from "./chunk-IDUKVVV3.mjs";
import {
  __async
} from "./chunk-VM2JCVBB.mjs";

// src/utils/browser.util.ts
var BrowserMemory = {
  set: function(_key, data) {
    return __async(this, null, function* () {
      const key = makeKey(_key);
      const text = yield data.response.clone().text();
      const resData = {
        responseBody: text,
        expiredAt: data.expiredAt,
        headers: Object.fromEntries(data.response.headers.entries()),
        status: data.response.status,
        statusText: data.response.statusText
      };
      window.localStorage.setItem(key, JSON.stringify(resData));
    });
  },
  get: function(_key) {
    const key = makeKey(_key);
    const raw = localStorage.getItem(key);
    if (!raw) return null;
    try {
      const parsed = JSON.parse(raw);
      const { responseBody, expiredAt, headers, status, statusText } = parsed;
      return {
        expiredAt,
        response: new Response(responseBody, {
          headers,
          status,
          statusText
        })
      };
    } catch (e) {
      return null;
    }
  },
  has: function(_key) {
    const key = makeKey(_key);
    return localStorage.getItem(key) !== null;
  },
  delete: function(_key) {
    const key = makeKey(_key);
    localStorage.removeItem(key);
  },
  clear: function() {
    const keys = Object.keys(localStorage);
    for (const key of keys) {
      if (key.startsWith("__CACHE_KIT__::")) {
        localStorage.removeItem(key);
      }
    }
  }
};

// src/adapters/browser.ts
var browserCachedFetch = (normalizedUrl, options, cacheOptions) => __async(null, null, function* () {
  const cacheKey = normalizedUrl;
  let response;
  if (cacheOptions.strategy === "cache-first") {
    if (BrowserMemory.has(cacheKey) && BrowserMemory.get(cacheKey).expiredAt > Date.now()) {
      response = BrowserMemory.get(cacheKey).response.clone();
    } else {
      const res = yield fetch(normalizedUrl, options);
      const cacheData = {
        response: res.clone(),
        expiredAt: getExpiryTimeCacheKey(cacheOptions == null ? void 0 : cacheOptions.revalidate)
      };
      yield BrowserMemory.set(cacheKey, cacheData);
      response = res;
    }
  } else if (cacheOptions.strategy === "network-first") {
    let res;
    try {
      res = yield fetch(normalizedUrl, options);
      const cacheData = {
        response: res.clone(),
        expiredAt: getExpiryTimeCacheKey(cacheOptions == null ? void 0 : cacheOptions.revalidate)
      };
      yield BrowserMemory.set(cacheKey, cacheData);
      response = res;
    } catch (err) {
      if (BrowserMemory.has(cacheKey) && BrowserMemory.get(cacheKey).expiredAt > Date.now()) {
        response = BrowserMemory.get(cacheKey).response.clone();
      } else {
        throw new Error(`Network fetch failed and no cache available: ${err}`);
      }
    }
  } else if (cacheOptions.strategy === "stale-while-revalidate") {
    if (BrowserMemory.has(cacheKey)) {
      response = BrowserMemory.get(cacheKey).response.clone();
    }
    fetch(normalizedUrl, options).then((res) => BrowserMemory.set(cacheKey, {
      response: res,
      expiredAt: getExpiryTimeCacheKey(cacheOptions == null ? void 0 : cacheOptions.revalidate)
    })).catch((err) => {
      console.warn("Background revalidation failed:", err);
    });
  }
  if (!response) {
    throw new Error("No valid response available.");
  }
  return response;
});
var browser_default = browserCachedFetch;
export {
  browser_default as default
};