castle-web-sdk 0.4.19 → 0.4.21

package/dist/commands.d.ts

@@ -62,6 +62,7 @@ export interface CommandParams {
     "deckStorage.load": Record<string, never>;
     "deckStorage.update": {
         updates: StorageUpdate[];
+        unload?: boolean;
     };
     "sharedDeckStorage.load": {
         scope: SharedScope;
@@ -71,6 +72,7 @@ export interface CommandParams {
     "sharedDeckStorage.update": {
         scope: SharedScope;
         updates: StorageUpdate[];
+        unload?: boolean;
     };
     "leaderboard.fetch": {
         variable: string;

package/dist/storage.js

@@ -1,6 +1,6 @@
 import { CastleError } from "./errors";
 import { hostRequest } from "./transport";
-const FLUSH_INTERVAL_MS = 2000;
+const FLUSH_INTERVAL_MS = 1000;
 // Per-player private storage. The host stamps deckId/sessionId, so one deck
 // session = one stable blob: load once, then serve reads from cache and batch
 // writes on a 2s flush. Dirty writes overlay the server blob so an in-flight
@@ -38,12 +38,13 @@ class PrivateStorageImpl {
         this.cache = decodeStorageBlob(blob, "Storage.get");
         this.overlayDirty();
     }
-    async flush() {
+    async flush(unload = false) {
         if (this.dirty.size === 0)
             return;
         const snapshot = new Map(this.dirty);
         const { blob } = await hostRequest("deckStorage.update", {
             updates: updatesFromDirty(snapshot),
+            unload,
         });
         this.cache = decodeStorageBlob(blob, "Storage.flush");
         clearAcknowledgedDirty(this.dirty, snapshot);
@@ -58,6 +59,7 @@ class PrivateStorageImpl {
         }
     }
     scheduleFlush() {
+        hookUnloadFlush();
         if (this.flushTimer)
             return;
         this.flushTimer = setTimeout(() => {
@@ -65,6 +67,9 @@ class PrivateStorageImpl {
             void this.flush();
         }, FLUSH_INTERVAL_MS);
     }
+    flushNow() {
+        void this.flush(true);
+    }
 }
 // Cross-player storage. Writes always target the current player (the host
 // forces 'user'-scope writes to whoever is signed in), so dirty writes bucket
@@ -151,18 +156,19 @@ class SharedStorageImpl {
                 read.resolve(value);
         }
     }
-    async flush() {
+    async flush(unload = false) {
         if (this.dirtyBuckets.size === 0)
             return;
-        const tasks = Array.from(this.dirtyBuckets, ([bucketKey, dirty]) => this.flushBucket(bucketKey, new Map(dirty)));
+        const tasks = Array.from(this.dirtyBuckets, ([bucketKey, dirty]) => this.flushBucket(bucketKey, new Map(dirty), unload));
         await Promise.all(tasks);
     }
-    async flushBucket(bucketKey, snapshot) {
+    async flushBucket(bucketKey, snapshot, unload = false) {
         if (snapshot.size === 0)
             return;
         await hostRequest("sharedDeckStorage.update", {
             scope: scopeFromWriteKey(bucketKey),
             updates: updatesFromDirty(snapshot),
+            unload,
         });
         const dirty = this.dirtyBuckets.get(bucketKey);
         if (!dirty)
@@ -172,6 +178,7 @@ class SharedStorageImpl {
             this.dirtyBuckets.delete(bucketKey);
     }
     scheduleFlush() {
+        hookUnloadFlush();
         if (this.flushTimer)
             return;
         this.flushTimer = setTimeout(() => {
@@ -179,6 +186,29 @@ class SharedStorageImpl {
             void this.flush().catch(reportSharedStorageError);
         }, FLUSH_INTERVAL_MS);
     }
+    flushNow() {
+        void this.flush(true).catch(reportSharedStorageError);
+    }
+}
+// Writes batch on a timer, so leaving the page inside that window would lose
+// them -- a deck saving progress as someone quits is exactly when it matters.
+// `pagehide` is the reliable signal on iOS, where unload often never fires, and
+// visibilitychange covers backgrounding without a navigation. Hooked on the
+// first write so a deck that never stores anything registers nothing.
+let unloadFlushHooked = false;
+function hookUnloadFlush() {
+    if (unloadFlushHooked || typeof window === "undefined")
+        return;
+    unloadFlushHooked = true;
+    const flush = () => {
+        Storage.flushNow();
+        SharedStorage.flushNow();
+    };
+    window.addEventListener("pagehide", flush);
+    document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden")
+            flush();
+    });
 }
 export const Storage = new PrivateStorageImpl();
 export const SharedStorage = new SharedStorageImpl();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-sdk",
-  "version": "0.4.19",
+  "version": "0.4.21",
   "type": "module",
   "main": "dist/castle.js",
   "types": "dist/castle.d.ts",