@geogirafe/lib-geoportal 1.2.0 → 1.2.1

package/package.json

@@ -5,7 +5,7 @@
     "name": "GeoGirafe PSC",
     "url": "https://doc.geogirafe.org"
   },
-  "version": "1.2.0",
+  "version": "1.2.1",
   "type": "module",
   "engines": {
     "node": ">=20.19.0"

package/templates/public/about.json

@@ -1 +1 @@
-{"version":"1.2.0", "build":"2922327721", "date":"07/10/2026"}
+{"version":"1.2.1", "build":"2968136297", "date":"20/10/2026"}

package/tools/app/geogirafeapp.d.ts

@@ -14,4 +14,6 @@ export default class GeoGirafeApp {
     protected defineCoreComponents(): void;
     private initializeServiceWorker;
     private waitForServiceWorkerControl;
+    private registerServiceWorker;
+    private waitForServiceWorkerActivation;
 }

package/tools/app/geogirafeapp.js

@@ -215,23 +215,18 @@ export default class GeoGirafeApp {
     }
     async waitForServiceWorkerControl() {
         const sw = navigator.serviceWorker;
-        const registration = await sw.register('service-worker.js', { type: 'module' });
+        const registration = await this.registerServiceWorker();
         // If a service worker already controls the current page, everything is ready.
         // `registration.active` only tells us that a service worker is active for the registration;
         // `sw.controller` tells us that it actually controls this page.
         if (sw.controller) {
             return sw.controller;
         }
-        // The page is not currently controlled by a service worker.
-        // This can happen, for example, after a force refresh (Ctrl+F5), even though
-        // an active service worker already exists. In that case, the service worker's
-        // `activate` event is not triggered again, so the `clients.claim()` call from
-        // the activation phase cannot take control of this newly loaded page.
-        // If an active service worker already exists, explicitly ask it to claim the
-        // current page. The service worker handles this message by calling `clients.claim()`.
-        const active = registration.active;
-        if (active) {
-            active.postMessage({ type: 'claim' });
+        // If the page is still outside of the service worker scope (see registerServiceWorker),
+        // the `controllerchange` event will never be fired, so we only wait for the service worker to be activated.
+        if (!globalThis.location.href.startsWith(registration.scope)) {
+            console.warn(`The current page is outside of the service worker scope (${registration.scope}), it won't be controlled by the service worker.`);
+            return this.waitForServiceWorkerActivation(registration);
         }
         // Wait until the service worker takes control of the current page.
         // Once `clients.claim()` succeeds, the browser updates `sw.controller` and
@@ -243,6 +238,60 @@ export default class GeoGirafeApp {
                     resolve(controller);
                 }
             }, { once: true });
+            // The page is not currently controlled by a service worker.
+            // This can happen, for example, after a force refresh (Ctrl+F5), even though
+            // an active service worker already exists. In that case, the service worker's
+            // `activate` event is not triggered again, so the `clients.claim()` call from
+            // the activation phase cannot take control of this newly loaded page.
+            // If an active service worker already exists, explicitly ask it to claim the
+            // current page. The service worker handles this message by calling `clients.claim()`.
+            const active = registration.active;
+            if (active) {
+                active.postMessage({ type: 'claim' });
+            }
+            // Safety check: This is exactly the same test as the begining of the method
+            // but the worker may have claimed the page before the listener
+            // above was registered, in which case `controllerchange` never fires.
+            if (sw.controller) {
+                resolve(sw.controller);
+            }
+        });
+    }
+    async registerServiceWorker() {
+        // The default scope of the service worker is the folder of service-worker.js (resolved against <base href>).
+        // When the application page is served from another path than its static files
+        // (e.g. page at /iframe and files at /static/), the page is outside of this scope and can't be controlled.
+        // In that case, try to register the service worker at path of the page as scope.
+        // This is only allowed by the browser if the server sends the "Service-Worker-Allowed" header.
+        const scriptUrl = new URL('service-worker.js', document.baseURI);
+        const defaultScope = new URL('./', scriptUrl).href;
+        if (!globalThis.location.href.startsWith(defaultScope)) {
+            const pageScope = new URL('./', globalThis.location.href).href;
+            try {
+                return await navigator.serviceWorker.register(scriptUrl, { type: 'module', scope: pageScope });
+            }
+            catch (err) {
+                console.warn(`Service worker could not be registered with the scope ${pageScope}. ` +
+                    `Check that the server sends the header "Service-Worker-Allowed" with the service worker script.`, err);
+            }
+        }
+        return navigator.serviceWorker.register(scriptUrl, { type: 'module' });
+    }
+    async waitForServiceWorkerActivation(registration) {
+        if (registration.active) {
+            return registration.active;
+        }
+        const sw = registration.installing ?? registration.waiting;
+        if (!sw) {
+            throw new Error('No service worker is installing or waiting.');
+        }
+        return new Promise((resolve) => {
+            sw.addEventListener('statechange', function onStateChange() {
+                if (sw.state === 'activated') {
+                    sw.removeEventListener('statechange', onStateChange);
+                    resolve(sw);
+                }
+            });
         });
     }
 }