Nouvelle version de sw.js pour prendre en compte les nouvelles version (pb de cache sinon) + nouveaux accès pour passer de l'API Poc à la version définitive

deploy/sw.js

@@ -1,12 +1,22 @@
-// Service worker du client ShipHeart.
-// Stratégie "cache d'abord" pour la coquille statique de l'app (mêmes fichiers
-// que le domaine de la page elle-même), MAIS jamais pour les appels vers
-// l'API (données live, cross-origine) - ceux-ci passent toujours par le
-// réseau, sans jamais être mis en cache, sous peine de figer les données
-// affichées (rencontré concrètement : rafraîchissement périodique et même
-// rechargement de page ne montraient plus jamais de valeurs à jour).
+// Service worker du client ShipHeart (synthèse §49).
+//
+// Coquille statique de l'app (index.html, wasm, JS, icônes) : "cache d'abord" - le wasm pèse ~25 Mo, il ne doit
+// pas être retéléchargé à chaque ouverture (connexion mobile en mer). Mais avec une MISE À JOUR FIABLE :
+//   1. CACHE_NAME porte l'horodatage du déploiement : toute nouvelle version modifie sw.js, que le navigateur
+//      revérifie à chaque ouverture -> installation d'une nouvelle version du service worker ;
+//   2. à l'installation, les fichiers sont téléchargés en CONTOURNANT le cache HTTP du navigateur
+//      (cache: "reload") - sinon, la nouvelle version pouvait se remplir avec les anciens fichiers gardés par ce
+//      cache (cas rencontré : ancien wasm toujours servi après un déploiement) ;
+//   3. à l'activation, les anciens caches sont supprimés et, s'il y en avait (= c'est une MISE À JOUR, pas une
+//      première installation), les pages ouvertes sont rechargées une fois : elles exécutent aussitôt la nouvelle
+//      version, sans action de l'utilisateur.
+//
+// Jamais de cache (le navigateur traite la requête normalement, sans passer par ce service worker) :
+//   - l'API (/api/..., même origine depuis la synthèse §49) : données live - un cache figerait les valeurs ;
+//   - l'ouverture de session Live (/_auth) ;
+//   - toute requête autre que GET, et toute requête vers une autre origine.
 
-const CACHE_NAME = "shipheart-wasm-v1";
+const CACHE_NAME = "shipheart-wasm-20261005_193211";		// Horodatage posé par le déploiement - ne pas modifier à la main
 const APP_SHELL = [
   "./index.html",
   "./qtloader.js",
@@ -23,7 +33,8 @@ self.addEventListener("install", (event) => {
     caches.open(CACHE_NAME).then((cache) =>
       Promise.allSettled(
         APP_SHELL.map((url) =>
-          cache.add(url).catch((err) => console.warn("Échec de mise en cache:", url, err))
+          cache.add(new Request(url, { cache: "reload" }))     // jamais le cache HTTP du navigateur (point 2)
+            .catch((err) => console.warn("Échec de mise en cache:", url, err))
         )
       )
     )
@@ -32,34 +43,41 @@ self.addEventListener("install", (event) => {
 });
 
 self.addEventListener("activate", (event) => {
-  event.waitUntil(
-    caches.keys().then((keys) =>
-      Promise.all(
-        keys.filter((key) => key !== CACHE_NAME).map((key) => caches.delete(key))
-      )
-    )
-  );
-  self.clients.claim();
+  event.waitUntil((async () => {
+    const anciens = (await caches.keys()).filter((key) => key !== CACHE_NAME);
+    await Promise.all(anciens.map((key) => caches.delete(key)));
+    await self.clients.claim();
+
+    // Mise à jour (et non première installation) : recharger les pages ouvertes, qui exécutent encore l'ancienne
+    // version (point 3). NB : rechargement lancé SANS l'attendre - le navigateur ne transmet les requêtes de la page
+    // rechargée à ce service worker qu'une fois l'activation terminée ; l'attendre ici bloquerait les deux
+    // indéfiniment (constaté en test).
+    if (anciens.length > 0) {
+      const fenetres = await self.clients.matchAll({ type: "window" });
+      for (const fenetre of fenetres) {
+        fenetre.navigate(fenetre.url).catch((err) => console.warn("Rechargement impossible:", fenetre.url, err));
+      }
+    }
+  })());
 });
 
 self.addEventListener("fetch", (event) => {
-  const url = new URL(event.request.url);
+  const requete = event.request;
+  const url = new URL(requete.url);
 
-  // Appels vers l'API (données live, autre origine) : jamais de cache,
-  // toujours le réseau.
-  if (url.origin !== self.location.origin) {
-    event.respondWith(fetch(event.request));
-    return;
-  }
+  // Hors coquille statique : pas de respondWith -> le navigateur traite la requête normalement (réseau).
+  if (requete.method !== "GET") return;
+  if (url.origin !== self.location.origin) return;
+  if (url.pathname.startsWith("/api/") || url.pathname === "/_auth") return;
 
-  // Coquille statique de l'app (même origine) : cache d'abord, comme avant.
+  // Coquille statique : cache d'abord, réseau sinon (et mise en cache de la réponse).
   event.respondWith(
-    caches.match(event.request).then((cached) => {
+    caches.match(requete).then((cached) => {
       if (cached) return cached;
-      return fetch(event.request).then((response) => {
+      return fetch(requete).then((response) => {
         if (response && response.ok) {
           const responseClone = response.clone();
-          caches.open(CACHE_NAME).then((cache) => cache.put(event.request, responseClone));
+          caches.open(CACHE_NAME).then((cache) => cache.put(requete, responseClone));
         }
         return response;
       });