sw.js

const CORE_ASSETS = [
    '/',
    '/index.html',
    '/styles.css',
    '/main.js',
    '/modules/api.js',
    '/modules/highlights.js',
    '/modules/hotkeys.js', 
    '/modules/mobile.js',
    '/modules/navigation.js',
    '/modules/passage.js', 
    '/modules/settings.js',
    '/modules/state.js',
    '/modules/strongs.js', 
    '/modules/ui.js',
    '/sw.js', '/404.html',
    '/manifest.json',
    '/favicons/apple-touch-icon.png',
    '/favicons/favicon.png',
    '/favicons/favicon-16x16.png',
    '/favicons/favicon-32x32.png',
    '/favicons/favicon-192x192.png',
    '/favicons/favicon-512x512.png',
    'https://cdn.jsdelivr.net/npm/marked/marked.min.js',
    'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css'
];
let CURRENT_CACHE = 'provinent-cache-v-initial';
self.addEventListener('message', e => {
    if (e.data?.type === 'VERSION') {
        const newCacheName = `provinent-cache-v${e.data.version}`;
        if (newCacheName !== CURRENT_CACHE) {
            CURRENT_CACHE = newCacheName;
            preCacheCoreAssets();
        }
    }
});
async function preCacheCoreAssets() {
    if (!CURRENT_CACHE) return;
    const cache = await caches.open(CURRENT_CACHE);
    const results = await Promise.allSettled(
        CORE_ASSETS.map(async url => {
            try {
                const isExternal = url.startsWith('http');
                const request = new Request(url, isExternal ? { mode: 'cors' } : { credentials: 'same-origin' });
                const response = await fetch(request);
                if (!response.ok && !isExternal) throw new Error(`HTTP ${response.status}`);
                await cache.put(url, response);
            } catch (err) {
                throw new Error(`Failed to cache ${url}: ${err.message}`);
            }
        })
    );
    results.forEach((result, index) => {
        if (result.status === 'rejected') {
            console.warn(`[SW] ${result.reason}`);
        }
    });
    console.log('[SW] Core assets caching completed for', CURRENT_CACHE);
}
self.addEventListener('install', () => self.skipWaiting());
self.addEventListener('activate', evt => {
    evt.waitUntil(
        (async () => {
            const names = await caches.keys();
            await Promise.all(
                names.map(name =>
                    name !== CURRENT_CACHE && name.startsWith('provinent-cache-v')
                        ? caches.delete(name)
                        : null
                )
            );
            await self.clients.claim();
        })()
    );
});
self.addEventListener('fetch', evt => {
    if (evt.request.method !== 'GET') return;
    if (evt.request.mode === 'navigate') {
        evt.respondWith(
            fetch(evt.request)
                .then(resp => {
                    if (shouldCache(evt.request, resp)) {
                        const copy = resp.clone();
                        caches.open(CURRENT_CACHE).then(c => c.put(evt.request, copy));
                    }
                    return resp;
                })
                .catch(async () => {
                    const cached = await caches.match(evt.request);
                    return cached || await caches.match('/index.html') || await caches.match('/404.html');
                })
        );
        return;
    }
    evt.respondWith(
        fetch(evt.request)
            .then(resp => {
                if (shouldCache(evt.request, resp)) {
                    const copy = resp.clone();
                    caches.open(CURRENT_CACHE).then(c => c.put(evt.request, copy));
                }
                return resp;
            })
            .catch(async () => {
                const cachedResponse = await caches.match(evt.request);
                if (cachedResponse) {
                    return cachedResponse;
                }
                return new Response(JSON.stringify({ error: 'Offline and not cached' }), {
                    status: 503,
                    statusText: 'Service Unavailable',
                    headers: { 'Content-Type': 'application/json' }
                });
            })
    );
});
function shouldCache(request, response) {
    return (
        CURRENT_CACHE &&
        isHttpScheme(request.url) &&
        response.type !== 'opaque' &&
        response.ok
    );
}
function isHttpScheme(url) {
    try {
        const u = new URL(url);
        return u.protocol === 'http:' || u.protocol === 'https:';
    } catch (_) {
        return false;
    }
}