cache-kit/cdn/browser-CCDRMnUN.js

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

import { _ as __awaiter } from './index-2gRjNNLr.js';
import { m as makeKey, g as getExpiryTimeCacheKey } from './common.util-CWC4ins0.js';

const BrowserMemory = {
    set: function (_key, data) {
        return __awaiter(this, void 0, void 0, 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 (_a) {
            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);
            }
        }
    }
};

const browserCachedFetch = (normalizedUrl, options, cacheOptions) => __awaiter(void 0, void 0, void 0, 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 || cacheOptions === void 0 ? 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 || cacheOptions === void 0 ? 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 || cacheOptions === void 0 ? void 0 : cacheOptions.revalidate)
        })).catch(err => {
            console.warn('Background revalidation failed:', err);
        });
    }
    if (!response) {
        throw new Error('No valid response available.');
    }
    return response;
});

export { browserCachedFetch as default };
//# sourceMappingURL=browser-CCDRMnUN.js.map