Fetch latest changes to turbo-offline

Author: rosa

app/assets/javascripts/turbo-offline-umd.js

@@ -4,16 +4,21 @@
 })(this, (function(exports) {
   "use strict";
   /*!
-  Turbo 8.0.20
-  Copyright © 2025 37signals LLC
+  Turbo 8.0.21
+  Copyright © 2026 37signals LLC
    */  class Rule {
-    constructor({handler: handler, match: match = /.*/} = {}) {
+    constructor({handler: handler, match: match = /.*/, except: except} = {}) {
       this.handler = handler;
       this.match = match;
+      this.except = except;
     }
     matches(request) {
-      if (typeof this.match === "function") return this.match(request);
-      const regexes = Array.isArray(this.match) ? this.match : [ this.match ];
+      return this.#matchesCondition(request, this.match) && !this.#matchesCondition(request, this.except);
+    }
+    #matchesCondition(request, condition) {
+      if (!condition) return false;
+      if (typeof condition === "function") return condition(request);
+      const regexes = Array.isArray(condition) ? condition : [ condition ];
       return regexes.some((regex => regex.test(request.url)));
     }
     async handle(event) {
@@ -22,60 +27,24 @@
       return response;
     }
   }
-  class ServiceWorker {
-    #started=false;
-    #rules=[];
-    addRule(rule) {
-      this.#rules.push(new Rule(rule));
-    }
-    start() {
-      this.#warnIfNoRulesConfigured();
-      if (!this.#started) {
-        self.addEventListener("install", this.installed);
-        self.addEventListener("message", this.messageReceived);
-        self.addEventListener("fetch", this.fetch);
-        this.#started = true;
-      }
-    }
-    installed=event => {
-      console.log("Service worker installed");
-    };
-    messageReceived=event => {
-      if (this[event.data.action]) {
-        const actionCall = this[event.data.action](event.data.params);
-        event.waitUntil(actionCall);
-      }
-    };
-    fetch=event => {
-      if (this.#canInterceptRequest(event.request)) {
-        const rule = this.#findMatchingRule(event.request);
-        if (!rule) return;
-        const response = rule.handle(event);
-        event.respondWith(response);
-      }
-    };
-    #warnIfNoRulesConfigured() {
-      if (this.#rules.length === 0) {
-        console.warn("No rules configured for service worker. No requests will be intercepted.");
-      }
-    }
-    #canInterceptRequest(request) {
-      const url = new URL(request.url, location.href);
-      return request.method === "GET" && url.protocol.startsWith("http");
-    }
-    #findMatchingRule(request) {
-      return this.#rules.find((rule => rule.matches(request)));
-    }
-  }
   const DATABASE_NAME = "turbo-offline-database";
   const DATABASE_VERSION = 1;
   const STORE_NAME = "cache-registry";
+  function deleteCacheRegistries() {
+    return new Promise(((resolve, reject) => {
+      const request = indexedDB.deleteDatabase(DATABASE_NAME);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    })).then((() => {
+      cacheRegistryDatabase = null;
+    }));
+  }
   class CacheRegistryDatabase {
-    get(cacheName, key) {
+    get(key) {
       const getOp = store => this.#requestToPromise(store.get(key));
       return this.#performOperation(STORE_NAME, getOp, "readonly");
     }
-    has(cacheName, key) {
+    has(key) {
       const countOp = store => this.#requestToPromise(store.count(key));
       return this.#performOperation(STORE_NAME, countOp, "readonly").then((result => result === 1));
     }
@@ -92,8 +61,8 @@
       };
       return this.#performOperation(STORE_NAME, putOp, "readwrite");
     }
-    getTimestamp(cacheName, key) {
-      return this.get(cacheName, key).then((result => result?.timestamp));
+    getTimestamp(key) {
+      return this.get(key).then((result => result?.timestamp));
     }
     getOlderThan(cacheName, timestamp) {
       const getOlderThanOp = store => {
@@ -104,7 +73,7 @@
       };
       return this.#performOperation(STORE_NAME, getOlderThanOp, "readonly");
     }
-    delete(cacheName, key) {
+    delete(key) {
       const deleteOp = store => this.#requestToPromise(store.delete(key));
       return this.#performOperation(STORE_NAME, deleteOp, "readwrite");
     }
@@ -160,22 +129,72 @@
       this.database = getDatabase();
     }
     get(key) {
-      return this.database.get(this.cacheName, key);
+      return this.database.get(key);
     }
     has(key) {
-      return this.database.has(this.cacheName, key);
+      return this.database.has(key);
     }
     put(key, value = {}) {
       return this.database.put(this.cacheName, key, value);
     }
     getTimestamp(key) {
-      return this.database.getTimestamp(this.cacheName, key);
+      return this.database.getTimestamp(key);
     }
     getOlderThan(timestamp) {
       return this.database.getOlderThan(this.cacheName, timestamp);
     }
     delete(key) {
-      return this.database.delete(this.cacheName, key);
+      return this.database.delete(key);
+    }
+  }
+  class ServiceWorker {
+    #started=false;
+    #rules=[];
+    addRule(rule) {
+      this.#rules.push(new Rule(rule));
+    }
+    start() {
+      this.#warnIfNoRulesConfigured();
+      if (!this.#started) {
+        self.addEventListener("install", this.installed);
+        self.addEventListener("message", this.messageReceived);
+        self.addEventListener("fetch", this.fetch);
+        this.#started = true;
+      }
+    }
+    installed=event => {
+      console.log("Service worker installed");
+    };
+    messageReceived=event => {
+      if (this[event.data.action]) {
+        const actionCall = this[event.data.action](event.data.params);
+        event.waitUntil(actionCall);
+      }
+    };
+    fetch=event => {
+      if (this.#canInterceptRequest(event.request)) {
+        const rule = this.#findMatchingRule(event.request);
+        if (!rule) return;
+        const response = rule.handle(event);
+        event.respondWith(response);
+      }
+    };
+    async clearCache() {
+      const cacheNames = await caches.keys();
+      await Promise.all(cacheNames.map((name => caches.delete(name))));
+      await deleteCacheRegistries();
+    }
+    #warnIfNoRulesConfigured() {
+      if (this.#rules.length === 0) {
+        console.warn("No rules configured for service worker. No requests will be intercepted.");
+      }
+    }
+    #canInterceptRequest(request) {
+      const url = new URL(request.url, location.href);
+      return request.method === "GET" && url.protocol.startsWith("http");
+    }
+    #findMatchingRule(request) {
+      return this.#rules.find((rule => rule.matches(request)));
     }
   }
   class CacheTrimmer {
@@ -262,12 +281,27 @@
         const cachePromise = cache.put(cacheKeyUrl, response);
         const registryPromise = this.cacheRegistry.put(cacheKeyUrl);
         const trimPromise = this.cacheTrimmer.trim();
-        return Promise.all([ cachePromise, registryPromise, trimPromise ]);
+        return Promise.all([ cachePromise, registryPromise, trimPromise ]).catch((async error => {
+          if (this.#isQuotaExceededError(error)) {
+            await this.#clearAllStorage();
+          }
+          throw error;
+        }));
       }
     }
     canCacheResponse(response) {
       return response.status === 200 || response.status === 0;
     }
+    #isQuotaExceededError(error) {
+      return error?.name === "QuotaExceededError" || error?.inner && error.inner.name === "QuotaExceededError";
+    }
+    async #clearAllStorage() {
+      const cacheNames = await caches.keys();
+      for (const cacheName of cacheNames) {
+        await caches.delete(cacheName);
+      }
+      await deleteCacheRegistries();
+    }
   }
   function buildCacheKey(requestOrUrl, response) {
     const request = new Request(requestOrUrl);