@arkade-os/sdk 0.4.0-next.3 → 0.4.0-next.4

package/dist/cjs/worker/browser/service-worker-manager.js

@@ -4,15 +4,111 @@ exports.__resetServiceWorkerManager = void 0;
 exports.setupServiceWorkerOnce = setupServiceWorkerOnce;
 exports.getActiveServiceWorker = getActiveServiceWorker;
 const registrations = new Map();
+let handshakes = new WeakSet();
 function ensureServiceWorkerSupport() {
     if (!("serviceWorker" in navigator)) {
         throw new Error("Service workers are not supported in this browser");
     }
 }
-function registerOnce(path) {
+function debugLog(debug, ...args) {
+    if (debug) {
+        // eslint-disable-next-line no-console
+        console.debug(...args);
+    }
+}
+function normalizeOptions(pathOrOptions) {
+    if (typeof pathOrOptions === "string") {
+        return {
+            path: pathOrOptions,
+            updateViaCache: "none",
+            autoReload: true,
+            debug: false,
+            activationTimeoutMs: 10000,
+        };
+    }
+    return {
+        path: pathOrOptions.path,
+        updateViaCache: pathOrOptions.updateViaCache ?? "none",
+        autoReload: pathOrOptions.autoReload ?? true,
+        onNeedRefresh: pathOrOptions.onNeedRefresh,
+        onUpdated: pathOrOptions.onUpdated,
+        debug: pathOrOptions.debug ?? false,
+        activationTimeoutMs: pathOrOptions.activationTimeoutMs ?? 10000,
+    };
+}
+function sendSkipWaiting(worker, debug) {
+    if (!worker)
+        return;
+    try {
+        worker.postMessage({ type: "SKIP_WAITING" });
+        debugLog(debug, "Sent SKIP_WAITING to waiting service worker");
+    }
+    catch (error) {
+        console.warn("Failed to post SKIP_WAITING to service worker", error);
+    }
+}
+function attachUpdateHandlers(registration, options) {
+    // Guard: only the first caller per registration attaches handlers.
+    // Subsequent calls with different options are silently ignored.
+    if (handshakes.has(registration))
+        return;
+    handshakes.add(registration);
+    const { autoReload, onNeedRefresh, onUpdated, activationTimeoutMs, debug } = options;
+    let reloadTriggered = false;
+    const maybeReload = () => {
+        if (reloadTriggered)
+            return;
+        reloadTriggered = true;
+        debugLog(debug, "Service worker controller change detected");
+        onUpdated?.();
+        if (autoReload &&
+            typeof window !== "undefined" &&
+            typeof window.location?.reload === "function") {
+            window.location.reload();
+        }
+    };
+    const handleWaiting = (worker) => {
+        if (!worker)
+            return;
+        onNeedRefresh?.();
+        sendSkipWaiting(worker, debug);
+        if (activationTimeoutMs > 0 && typeof window !== "undefined") {
+            window.setTimeout(() => {
+                if (registration.waiting) {
+                    debugLog(debug, "Waiting worker still pending; re-sending SKIP_WAITING");
+                    sendSkipWaiting(registration.waiting, debug);
+                    registration
+                        .update()
+                        .catch(() => debugLog(debug, "Service worker update retry failed (timeout path)"));
+                }
+            }, activationTimeoutMs);
+        }
+    };
+    // Handle an already waiting worker at startup.
+    if (registration.waiting) {
+        handleWaiting(registration.waiting);
+    }
+    // Listen for newly installed workers becoming waiting.
+    registration.addEventListener("updatefound", () => {
+        const installing = registration.installing;
+        if (!installing)
+            return;
+        installing.addEventListener("statechange", () => {
+            if (installing.state === "installed") {
+                handleWaiting(registration.waiting);
+            }
+        });
+    });
+    // Reload (or callback) once the new controller takes over.
+    navigator.serviceWorker.addEventListener("controllerchange", maybeReload, {
+        once: true,
+    });
+}
+function registerOnce(options) {
+    const { path, updateViaCache } = options;
     if (!registrations.has(path)) {
         const registrationPromise = navigator.serviceWorker
-            .register(path)
+            .register(path, { updateViaCache })
             .then(async (registration) => {
             try {
                 await registration.update();
@@ -29,18 +125,23 @@ function registerOnce(path) {
         });
         registrations.set(path, registrationPromise);
     }
-    return registrations.get(path);
+    return registrations.get(path).then((registration) => {
+        attachUpdateHandlers(registration, options);
+        return registration;
+    });
 }
 /**
- * Registers a service worker for the given path only once and caches the
- * registration promise for subsequent calls.
+ * Registers a service worker for the given path only once, attaches an
+ * update/activation handshake (SKIP_WAITING + controllerchange reload), and
+ * caches the registration promise for subsequent calls.
  *
- * @param path - Service worker script path to register.
+ * @param pathOrOptions - Service worker script path or a configuration object.
  * @throws if service workers are not supported or registration fails.
  */
-async function setupServiceWorkerOnce(path) {
+async function setupServiceWorkerOnce(pathOrOptions) {
     ensureServiceWorkerSupport();
-    return registerOnce(path);
+    const options = normalizeOptions(pathOrOptions);
+    return registerOnce(options);
 }
 /**
  * Returns an active service worker instance, optionally ensuring a specific
@@ -51,9 +152,8 @@ async function setupServiceWorkerOnce(path) {
  */
 async function getActiveServiceWorker(path) {
     ensureServiceWorkerSupport();
-    // Avoid mixing registrations when a specific script path is provided.
     const registration = path
-        ? await registerOnce(path)
+        ? await registerOnce(normalizeOptions(path))
         : await navigator.serviceWorker.ready;
     let serviceWorker = registration.active ||
         registration.waiting ||
@@ -78,5 +178,6 @@ async function getActiveServiceWorker(path) {
  */
 const __resetServiceWorkerManager = () => {
     registrations.clear();
+    handshakes = new WeakSet();
 };
 exports.__resetServiceWorkerManager = __resetServiceWorkerManager;

package/dist/esm/worker/browser/service-worker-manager.js

@@ -1,13 +1,109 @@
 const registrations = new Map();
+let handshakes = new WeakSet();
 function ensureServiceWorkerSupport() {
     if (!("serviceWorker" in navigator)) {
         throw new Error("Service workers are not supported in this browser");
     }
 }
-function registerOnce(path) {
+function debugLog(debug, ...args) {
+    if (debug) {
+        // eslint-disable-next-line no-console
+        console.debug(...args);
+    }
+}
+function normalizeOptions(pathOrOptions) {
+    if (typeof pathOrOptions === "string") {
+        return {
+            path: pathOrOptions,
+            updateViaCache: "none",
+            autoReload: true,
+            debug: false,
+            activationTimeoutMs: 10000,
+        };
+    }
+    return {
+        path: pathOrOptions.path,
+        updateViaCache: pathOrOptions.updateViaCache ?? "none",
+        autoReload: pathOrOptions.autoReload ?? true,
+        onNeedRefresh: pathOrOptions.onNeedRefresh,
+        onUpdated: pathOrOptions.onUpdated,
+        debug: pathOrOptions.debug ?? false,
+        activationTimeoutMs: pathOrOptions.activationTimeoutMs ?? 10000,
+    };
+}
+function sendSkipWaiting(worker, debug) {
+    if (!worker)
+        return;
+    try {
+        worker.postMessage({ type: "SKIP_WAITING" });
+        debugLog(debug, "Sent SKIP_WAITING to waiting service worker");
+    }
+    catch (error) {
+        console.warn("Failed to post SKIP_WAITING to service worker", error);
+    }
+}
+function attachUpdateHandlers(registration, options) {
+    // Guard: only the first caller per registration attaches handlers.
+    // Subsequent calls with different options are silently ignored.
+    if (handshakes.has(registration))
+        return;
+    handshakes.add(registration);
+    const { autoReload, onNeedRefresh, onUpdated, activationTimeoutMs, debug } = options;
+    let reloadTriggered = false;
+    const maybeReload = () => {
+        if (reloadTriggered)
+            return;
+        reloadTriggered = true;
+        debugLog(debug, "Service worker controller change detected");
+        onUpdated?.();
+        if (autoReload &&
+            typeof window !== "undefined" &&
+            typeof window.location?.reload === "function") {
+            window.location.reload();
+        }
+    };
+    const handleWaiting = (worker) => {
+        if (!worker)
+            return;
+        onNeedRefresh?.();
+        sendSkipWaiting(worker, debug);
+        if (activationTimeoutMs > 0 && typeof window !== "undefined") {
+            window.setTimeout(() => {
+                if (registration.waiting) {
+                    debugLog(debug, "Waiting worker still pending; re-sending SKIP_WAITING");
+                    sendSkipWaiting(registration.waiting, debug);
+                    registration
+                        .update()
+                        .catch(() => debugLog(debug, "Service worker update retry failed (timeout path)"));
+                }
+            }, activationTimeoutMs);
+        }
+    };
+    // Handle an already waiting worker at startup.
+    if (registration.waiting) {
+        handleWaiting(registration.waiting);
+    }
+    // Listen for newly installed workers becoming waiting.
+    registration.addEventListener("updatefound", () => {
+        const installing = registration.installing;
+        if (!installing)
+            return;
+        installing.addEventListener("statechange", () => {
+            if (installing.state === "installed") {
+                handleWaiting(registration.waiting);
+            }
+        });
+    });
+    // Reload (or callback) once the new controller takes over.
+    navigator.serviceWorker.addEventListener("controllerchange", maybeReload, {
+        once: true,
+    });
+}
+function registerOnce(options) {
+    const { path, updateViaCache } = options;
     if (!registrations.has(path)) {
         const registrationPromise = navigator.serviceWorker
-            .register(path)
+            .register(path, { updateViaCache })
             .then(async (registration) => {
             try {
                 await registration.update();
@@ -24,18 +120,23 @@ function registerOnce(path) {
         });
         registrations.set(path, registrationPromise);
     }
-    return registrations.get(path);
+    return registrations.get(path).then((registration) => {
+        attachUpdateHandlers(registration, options);
+        return registration;
+    });
 }
 /**
- * Registers a service worker for the given path only once and caches the
- * registration promise for subsequent calls.
+ * Registers a service worker for the given path only once, attaches an
+ * update/activation handshake (SKIP_WAITING + controllerchange reload), and
+ * caches the registration promise for subsequent calls.
  *
- * @param path - Service worker script path to register.
+ * @param pathOrOptions - Service worker script path or a configuration object.
  * @throws if service workers are not supported or registration fails.
  */
-export async function setupServiceWorkerOnce(path) {
+export async function setupServiceWorkerOnce(pathOrOptions) {
     ensureServiceWorkerSupport();
-    return registerOnce(path);
+    const options = normalizeOptions(pathOrOptions);
+    return registerOnce(options);
 }
 /**
  * Returns an active service worker instance, optionally ensuring a specific
@@ -46,9 +147,8 @@ export async function setupServiceWorkerOnce(path) {
  */
 export async function getActiveServiceWorker(path) {
     ensureServiceWorkerSupport();
-    // Avoid mixing registrations when a specific script path is provided.
     const registration = path
-        ? await registerOnce(path)
+        ? await registerOnce(normalizeOptions(path))
         : await navigator.serviceWorker.ready;
     let serviceWorker = registration.active ||
         registration.waiting ||
@@ -73,4 +173,5 @@ export async function getActiveServiceWorker(path) {
  */
 export const __resetServiceWorkerManager = () => {
     registrations.clear();
+    handshakes = new WeakSet();
 };

package/dist/types/worker/browser/service-worker-manager.d.ts

@@ -1,11 +1,21 @@
+type SetupServiceWorkerOptions = {
+    path: string;
+    updateViaCache?: ServiceWorkerUpdateViaCache;
+    autoReload?: boolean;
+    onNeedRefresh?: () => void;
+    onUpdated?: () => void;
+    debug?: boolean;
+    activationTimeoutMs?: number;
+};
 /**
- * Registers a service worker for the given path only once and caches the
- * registration promise for subsequent calls.
+ * Registers a service worker for the given path only once, attaches an
+ * update/activation handshake (SKIP_WAITING + controllerchange reload), and
+ * caches the registration promise for subsequent calls.
  *
- * @param path - Service worker script path to register.
+ * @param pathOrOptions - Service worker script path or a configuration object.
  * @throws if service workers are not supported or registration fails.
  */
-export declare function setupServiceWorkerOnce(path: string): Promise<ServiceWorkerRegistration>;
+export declare function setupServiceWorkerOnce(pathOrOptions: string | SetupServiceWorkerOptions): Promise<ServiceWorkerRegistration>;
 /**
  * Returns an active service worker instance, optionally ensuring a specific
  * script path is registered before resolving.
@@ -19,3 +29,4 @@ export declare function getActiveServiceWorker(path?: string): Promise<ServiceWo
  * Intended for tests to reset state between runs.
  */
 export declare const __resetServiceWorkerManager: () => void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/sdk",
-  "version": "0.4.0-next.3",
+  "version": "0.4.0-next.4",
   "description": "Bitcoin wallet SDK with Taproot and Ark integration",
   "type": "module",
   "main": "./dist/cjs/index.js",