kai.infotren/sw.js

const VERSION = 'v6'
const API_ORIGIN = 'https://scraper.infotren.dcdev.ro/'
const API_TRAINS = `${API_ORIGIN}v3/trains`
const API_STATIONS = `${API_ORIGIN}v2/stations`

self.addEventListener('install', (event) => {
  event.waitUntil(
    caches
      .open(VERSION)
      .then((cache) =>
        cache.addAll([
          // Root
          '/',

          // Utility JS
          '/worker.js',
          '/items.js',
          '/back.js',

          // Base
          '/base.css',

          // Pages
          '/index.html',

          '/about.html',

          '/train.html',
          '/train.js',

          '/view-train.html',
          '/view-train.js',
          '/view-train.css',

          // API
          API_TRAINS,
          API_STATIONS,

        ])
      )
  )
})

const deleteCache = (key) => caches.delete(key)

const deleteOldCaches = async () => {
   const cacheKeepList = [VERSION]
   const keyList = await caches.keys()
   const cachesToDelete = keyList.filter((key) => !cacheKeepList.includes(key))
   await Promise.all(cachesToDelete.map(deleteCache))
}

// Enable navigation preload
const enableNavigationPreload = async () => {
  if (self.registration.navigationPreload) {
    // Enable navigation preloads!
    await self.registration.navigationPreload.enable()
  }
}

self.addEventListener('activate', (event) => {
  event.waitUntil(Promise.all([deleteOldCaches(), enableNavigationPreload()]))
})

const putInCache = async (request, response) => {
  const cache = await caches.open(VERSION)
  await cache.put(request, response)
}

const cacheFirst = async ({ request, preloadResponsePromise, refreshAnyway }) => {
  // First try to get the resource from the cache
  const responseFromCache = await caches.match(request)
  if (responseFromCache) {
    if (refreshAnyway) {
      console.log('request in cache, refreshing anyway but returning cache', request);
      ((async () => {
        try {
          const response = await fetch(request)
          if (response.ok) {
            putInCache(request, response)
          }
        }
        catch {}
      })())
    }
    return responseFromCache
  }

  // Next try to use (and cache) the preloaded response, if it's there
  if (preloadResponsePromise) {
    const preloadResponse = await preloadResponsePromise
    if (preloadResponse && preloadResponse.ok) {
      console.info('using preload response', preloadResponse)
      putInCache(request, preloadResponse.clone())
      return preloadResponse
    }
    else {
      console.log('got not ok preloadResponse, ignoring', preloadResponse)
    }
  }

  // Next try to get the resource from the network
  const responseFromNetwork = await fetch(request)
  // response may be used only once
  // we need to save clone to put one copy in cache
  // and serve second one
  if (responseFromNetwork.ok) {
    putInCache(request, responseFromNetwork.clone())
  }
  return responseFromNetwork;
}

self.addEventListener('fetch', (event) => {
  event.respondWith(
    cacheFirst({
      request: event.request,
      preloadResponsePromise: event.preloadResponse,
      refreshAnyway: [API_STATIONS, API_TRAINS].includes(event.request.url),
    })
  )
})