onlyn00bs-badge

sw.js (3760B)

---

 /* badge.virtualshack.io — offline shell
  *
  * Why this exists: DEF CON's network is hostile and congested, and the setup app is
  * useless if you can't load it at the moment you need it.
  * Load the site once before you travel and it keeps working after.
  *
  * Strategy: precache the whole (tiny) site on install, then serve cache-first and
  * refresh in the background. Cache-first is deliberate — on a bad network, "instant
  * and slightly stale" beats "spinner forever".
  *
  * Bump CACHE on every content change, otherwise returning visitors keep the old copy
  * until the background refresh lands (i.e. one reload behind).
  *
  * Bump the ?v= on the stylesheet <link> in index.html to the SAME number at the same time.
  * index.html is served no-cache but /assets/ is not, so a CSS edit otherwise sits behind
  * Cloudflare's edge cache for hours after a deploy. Keeping the two numbers equal means
  * there is one version to remember, not two.
  */
 
 const CACHE = "onlyn00bs-v39";
 
 // Resolved against the worker's own location, so it's right whether the site is served at
 // / (production) or under a path (a local preview).
 const GALLERY_IMG = new URL("assets/gallery/", self.location).pathname;
 
 const PRECACHE = [
   "./",
   "index.html",
   "assets/badge.css",
   "assets/icon.svg",
   "manifest.webmanifest",
   // The setup app. Precached deliberately: this is THE page you need working on a hostile
   // con network, and it is self-contained (no imports, no external assets), so one entry
   // covers the whole flow. A --public build omits it and the cache.add 404s harmlessly
   // (see allSettled below).
   "provision/",
 ];
 
 self.addEventListener("install", (e) => {
   e.waitUntil((async () => {
     const cache = await caches.open(CACHE);
     // Individually, not addAll(): one 404 shouldn't fail the whole install and
     // leave a recipient with no offline copy at all.
     await Promise.allSettled(PRECACHE.map((url) => cache.add(new Request(url, { cache: "reload" }))));
     await self.skipWaiting();
   })());
 });
 
 self.addEventListener("activate", (e) => {
   e.waitUntil((async () => {
     const keys = await caches.keys();
     await Promise.all(keys.filter((k) => k !== CACHE).map((k) => caches.delete(k)));
     await self.clients.claim();
   })());
 });
 
 self.addEventListener("fetch", (e) => {
   const req = e.request;
   if (req.method !== "GET") return;
   const url = new URL(req.url);
   if (url.origin !== self.location.origin) return;   // never touch cross-origin
   // Gallery photos are network-only. Everything else this worker sees gets cached as it's
   // fetched, which is right for a ~2 MB site and wrong for a photo gallery: every photo
   // anyone ever opened would sit in their cache until the next CACHE bump. The gallery
   // page itself is still cached like any other page; only the images pass through.
   if (url.pathname.startsWith(GALLERY_IMG)) return;
 
   e.respondWith((async () => {
     const cache = await caches.open(CACHE);
     const hit = await cache.match(req, { ignoreSearch: true });
 
     const fresh = fetch(req)
       .then((res) => {
         if (res && res.ok && res.type === "basic") cache.put(req, res.clone());
         return res;
       })
       .catch(() => null);
 
     if (hit) return hit;                       // cache-first
 
     const res = await fresh;
     if (res) return res;
 
     // Offline and never cached: hand navigations the shell rather than a browser error.
     if (req.mode === "navigate") {
       const shell = await cache.match("./", { ignoreSearch: true }) || await cache.match("index.html");
       if (shell) return shell;
     }
     return new Response("offline — this page was never cached", {
       status: 503,
       headers: { "Content-Type": "text/plain" },
     });
   })());
 });