'use strict'; const VIDEO_STREAM_CACHE_NAME = 'filemanager-stream-cache-v1'; function isVideoStreamSegmentRequest (request) { if (!request || String(request.method || '').toUpperCase() !== 'GET') return false; let url = null; try { url = new URL(request.url); } catch { return false; } const pathname = String(url.pathname || ''); if (!pathname.startsWith('/api/')) return false; const isStreamAsset = pathname.startsWith('/api/files/video-stream/') || pathname.startsWith('/api/share/video-stream/'); if (!isStreamAsset) return false; // Cache only immutable segment/init assets. Avoid caching playlists because // stale manifests can break seek behaviour after the server prunes older entries. if (/\.m3u8(?:$|\?)/i.test(pathname)) return false; return /(?:\.ts|\.m4s|\.mp4|\.aac|\.vtt)(?:$|\?)/i.test(pathname); } function requestWithoutRange (request) { return new Request(request.url, { method: 'GET', credentials: request.credentials, mode: request.mode, redirect: request.redirect, referrer: request.referrer, referrerPolicy: request.referrerPolicy, integrity: request.integrity, cache: 'no-store', }); } function parseRangeHeader (rawHeader, size) { const header = String(rawHeader || '').trim().toLowerCase(); if (!header || !header.startsWith('bytes=')) return null; const [startRaw, endRaw] = header.slice('bytes='.length).split('-', 2); if (startRaw.includes(',') || (endRaw && endRaw.includes(','))) return null; let start = startRaw === '' ? null : Number.parseInt(startRaw, 10); let end = endRaw === '' ? null : Number.parseInt(endRaw, 10); if (start === null && end === null) return null; if (start !== null && (!Number.isInteger(start) || start < 0)) return null; if (end !== null && (!Number.isInteger(end) || end < 0)) return null; if (start === null) { const suffixLength = end; if (!Number.isInteger(suffixLength) || suffixLength <= 0) return null; start = Math.max(0, size - suffixLength); end = size - 1; } else if (end === null) { end = size - 1; } if (start >= size) return null; if (end >= size) end = size - 1; if (end < start) return null; return { start, end }; } async function buildRangeResponseFromCached (cachedResponse, rangeHeader) { if (!cachedResponse || !rangeHeader) return null; const clone = cachedResponse.clone(); const bodyBuffer = await clone.arrayBuffer(); const totalBytes = bodyBuffer.byteLength; const range = parseRangeHeader(rangeHeader, totalBytes); if (!range) return null; const slicedBody = bodyBuffer.slice(range.start, range.end + 1); const headers = new Headers(cachedResponse.headers || {}); headers.set('content-range', `bytes ${range.start}-${range.end}/${totalBytes}`); headers.set('content-length', String(range.end - range.start + 1)); headers.set('accept-ranges', 'bytes'); return new Response(slicedBody, { status: 206, statusText: 'Partial Content', headers, }); } self.addEventListener('install', (event) => { event.waitUntil(self.skipWaiting()); }); self.addEventListener('activate', (event) => { event.waitUntil(self.clients.claim()); }); self.addEventListener('fetch', (event) => { const request = event.request; if (!isVideoStreamSegmentRequest(request)) return; event.respondWith((async () => { const cache = await caches.open(VIDEO_STREAM_CACHE_NAME); const rangeHeader = request.headers && typeof request.headers.get === 'function' ? String(request.headers.get('range') || '').trim() : ''; const isRangeRequest = !!rangeHeader; const normalizedRequest = isRangeRequest ? requestWithoutRange(request) : request; const cached = await cache.match(normalizedRequest); try { const response = await fetch(request); const hasContentRange = response && response.headers && typeof response.headers.get === 'function' ? String(response.headers.get('content-range') || '').trim() : ''; if (response && response.ok && !hasContentRange) { void cache.put(normalizedRequest, response.clone()).catch(() => { // Cache writes are best-effort. }); return response; } if (response && (response.status === 206 || hasContentRange) && isRangeRequest) { // Warm a full-body cache entry in the background so rewinds can still // use cached segments if the server later prunes old files. void fetch(normalizedRequest).then((fullResponse) => { if (!fullResponse || !fullResponse.ok) return; return cache.put(normalizedRequest, fullResponse.clone()); }).catch(() => { // Full-body warmup is best-effort only. }); } if (cached) { if (isRangeRequest) { const rangeResponse = await buildRangeResponseFromCached(cached, rangeHeader); if (rangeResponse) return rangeResponse; } return cached; } return response; } catch { if (cached) { if (isRangeRequest) { const rangeResponse = await buildRangeResponseFromCached(cached, rangeHeader); if (rangeResponse) return rangeResponse; } return cached; } return new Response(null, { status: 504, statusText: 'Gateway Timeout', }); } })()); });