Something went wrong. Try again.
A music player that connects to your cloud/distributed storage. forked from tokono.ma/diffuse
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252/// <reference lib="webworker" />
import { create as createCid } from "./common/cid.js";
const fileTreePromise = import("./file-tree.json", { with: { type: "json" } }) .then((m) => m.default) .catch(() => null);
/** Media content types to ignore */const MEDIA_CONTENT_TYPE = /^(audio|video)\//;
/** Multicodec code for raw binary content. */const RAW_CODEC = 0x55;
const { searchParams } = new URL(location.href);const CACHE_NAME = searchParams.get("cache-name") ?? "diffuse-offline";
const thyself = /** @type {ServiceWorkerGlobalScope & typeof globalThis} */ (/** @type {unknown} */ (self));
////////////////////////////////////////////// INSTALL////////////////////////////////////////////
self.addEventListener("install", (_event) => { // Activate immediately without waiting for existing clients to close. /** @type {ExtendableEvent} */ (_event).waitUntil(thyself.skipWaiting());});
////////////////////////////////////////////// ACTIVATE////////////////////////////////////////////
self.addEventListener("activate", (event) => { // Take control of all open clients right away, then reload them so every // page starts fresh under the new service worker with no mid-session split. /** @type {ExtendableEvent} */ (event).waitUntil( thyself.clients.claim().then(() => thyself.clients.matchAll({ type: "window" }).then((clients) => { for (const client of clients) client.navigate(client.url); }) ) );});
////////////////////////////////////////////// FETCH////////////////////////////////////////////
self.addEventListener("fetch", (_event) => { const event = /** @type {FetchEvent} */ (_event); const { request } = event;
if (!request.url.startsWith("http")) return;
// Intercept credentialed URLs before the offline cache (any method). const intercepted = interceptCredentials(request); if (intercepted) { event.respondWith(intercepted); return; }
// Only cache GET requests. if (request.method !== "GET") return;
event.respondWith(handleFetch(request));});
////////////////////////////////////////////// CREDENTIAL INTERCEPT////////////////////////////////////////////
/** * If the request URL contains a `_auth` query parameter (base64 Basic credentials), * strip it and re-issue the request with a proper Authorization header instead. * Also handles the legacy `user:pass@host` form for any callers that still use it. * * Returns a Promise<Response> when credentials are detected, or null to fall through. * * @param {Request} request * @returns {Promise<Response> | null} */function interceptCredentials(request) { const url = new URL(request.url);
if (url.username) { const credentials = `${decodeURIComponent(url.username)}:${decodeURIComponent(url.password)}`; url.username = ""; url.password = ""; const headers = new Headers(request.headers); headers.set("Authorization", `Basic ${btoa(unescape(encodeURIComponent(credentials)))}`); return fetch(url.href, { method: request.method, headers, signal: request.signal }); }
const auth = url.searchParams.get("diffuse:basic-auth"); if (!auth) return null;
url.searchParams.delete("diffuse:basic-auth"); const headers = new Headers(request.headers); headers.set("Authorization", `Basic ${auth}`); return fetch(url.href, { method: request.method, headers, signal: request.signal });}
////////////////////////////////////////////// CONTENT-ADDRESSED CACHE////////////////////////////////////////////
/** * @param {string} cid */function cidUrl(cid) { return `https://diffuse.offline.worker/${cid}`;}
/** * Opens the two caches used for content-addressed storage. * * - `<name>:index` maps original request URL → CID string (text/plain) * - `<name>:content` maps `https://diffuse.offline.worker/<cid>` → full response (deduplicated) */async function openCaches() { const [index, content] = await Promise.all([ caches.open(CACHE_NAME + ":index"), caches.open(CACHE_NAME + ":content"), ]); return { index, content };}
/** * Looks up a pathname in the pre-built file tree and returns its CID, or * `undefined` if the entry is absent or the tree failed to load. * * @param {string} pathname - e.g. "/components/foo.js" * @returns {Promise<string | undefined>} */async function cidFromTree(pathname) { /** @type {Record<string, string> | null} */ const tree = await fileTreePromise; if (!tree) return undefined; const key = pathname.replace(/^\//, ""); return tree[key];}
/** * Computes the CID of `response`'s body and writes it into the two-level cache. * The same content is stored only once, regardless of how many URLs reference it. * * Uses the pre-built file tree CID when available; falls back to hashing the * response body when the entry is missing from the tree. * * @param {Request} request * @param {Response} response - a clone; its body is fully consumed here */async function store(request, response) { const { pathname } = new URL(request.url); const cid = await cidFromTree(pathname) ?? await createCid( RAW_CODEC, new Uint8Array(await response.clone().arrayBuffer()), ); const cidKey = cidUrl(cid);
const caches = await openCaches();
// Only store the content if we haven't seen this CID before if (!(await caches.content.match(cidKey))) { await caches.content.put(new Request(cidKey), response); }
// Update the URL → CID map await caches.index.put( new Request(request.url), new Response(cid, { headers: { "content-type": "text/plain" } }), );}
/** * Resolves the cached response for a request via the URL → CID index. * * @param {Request} request * @returns {Promise<Response | undefined>} */async function lookup(request) { const caches = await openCaches();
const indexEntry = await caches.index.match(request); if (!indexEntry) return undefined;
const cid = await indexEntry.text(); return caches.content.match(cidUrl(cid));}
////////////////////////////////////////////// HANDLER////////////////////////////////////////////
/** * Cache-first for file-tree entries, network-first for everything else. * * Online + in file tree → serve from cache if present, otherwise fetch and store. * Online + not in tree → fetch from network, store response by CID, return it. * Offline → resolve the URL through the index, serve by CID from the content cache. * * Partial responses (206) are passed through without caching so that * range requests for audio streaming work as normal. * * @param {Request} request * @returns {Promise<Response>} */async function handleFetch(request) { if (navigator.onLine) { const { pathname } = new URL(request.url); if (await cidFromTree(pathname) !== undefined) { const cached = await lookup(request); if (cached) return cached; }
try { return await fetchAndStore(request); } catch {} }
const cached = await lookup(request); if (cached) return cached;
return new Response(null, { status: 503, statusText: "Unavailable asset, not cached", });}
/** * @param {Request} request */async function fetchAndStore(request) { const response = await fetch(request);
// Partial content (range requests) — return as-is, do not cache. if (response.status === 206) return response;
// Skip caching audio/video. const contentType = response.headers.get("content-type") ?? ""; if (MEDIA_CONTENT_TYPE.test(contentType)) return response;
// Cache full successful responses, including opaque cross-origin ones. if (response.status === 200 || response.type === "opaque") { store(request, response.clone()).catch(() => {}); }
return response;}