@bountyboard/arcade-sdk 1.2.0 → 1.4.0

package/dist/global.js

@@ -5,6 +5,316 @@
   var SDK_MESSAGE_SOURCE = "bb-arcade";
   var HOST_MESSAGE_SOURCE = "bb-arcade-host";
 
+  // src/storage.ts
+  var FLUSH_DELAY_MS = 400;
+  var ENVELOPE_TAG = "__bbArcadeStorage";
+  var ENVELOPE_VERSION = 1;
+  function hasOwn(target, key) {
+    return Object.prototype.hasOwnProperty.call(target, key);
+  }
+  function emptyMap() {
+    return /* @__PURE__ */ Object.create(null);
+  }
+  function storageError(code) {
+    const err = new Error(code);
+    err.code = code;
+    return err;
+  }
+  function parseEnvelope(raw) {
+    if (raw == null) return { ls: {}, app: null };
+    if (raw.charAt(0) !== "{") return { ls: {}, app: raw };
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      return { ls: {}, app: raw };
+    }
+    if (!parsed || typeof parsed !== "object") return { ls: {}, app: raw };
+    const record = parsed;
+    if (record[ENVELOPE_TAG] !== ENVELOPE_VERSION) return { ls: {}, app: raw };
+    const ls = emptyMap();
+    const source = record.ls;
+    if (source && typeof source === "object") {
+      const entries = source;
+      for (const key in entries) {
+        if (hasOwn(entries, key) && typeof entries[key] === "string") {
+          ls[key] = entries[key];
+        }
+      }
+    }
+    return { ls, app: typeof record.app === "string" ? record.app : null };
+  }
+  function buildEnvelope(ls, app) {
+    const envelope = {};
+    envelope[ENVELOPE_TAG] = ENVELOPE_VERSION;
+    envelope.ls = ls;
+    envelope.app = app;
+    return JSON.stringify(envelope);
+  }
+  function quotaError() {
+    try {
+      return new DOMException("Cloud save quota exceeded", "QuotaExceededError");
+    } catch (err) {
+      const fallback = new Error("Cloud save quota exceeded");
+      fallback.name = "QuotaExceededError";
+      return fallback;
+    }
+  }
+  var RESERVED = {
+    getItem: true,
+    setItem: true,
+    removeItem: true,
+    clear: true,
+    key: true,
+    length: true
+  };
+  function createStorageShim(backend = {}) {
+    const map = emptyMap();
+    const localWrites = emptyMap();
+    function keys() {
+      return Object.keys(map);
+    }
+    function changed() {
+      if (backend.onChange) backend.onChange();
+    }
+    const api = {
+      getItem: function(key) {
+        const name = String(key);
+        return hasOwn(map, name) ? map[name] : null;
+      },
+      setItem: function(key, value) {
+        const name = String(key);
+        const next = String(value);
+        if (backend.wouldOverflow && backend.wouldOverflow(name, next)) throw quotaError();
+        map[name] = next;
+        localWrites[name] = true;
+        changed();
+      },
+      removeItem: function(key) {
+        const name = String(key);
+        localWrites[name] = true;
+        if (!hasOwn(map, name)) return;
+        delete map[name];
+        changed();
+      },
+      clear: function() {
+        const existing = keys();
+        for (let i = 0; i < existing.length; i++) {
+          delete map[existing[i]];
+          localWrites[existing[i]] = true;
+        }
+        changed();
+      },
+      key: function(index) {
+        const existing = keys();
+        const at = Number(index);
+        return at >= 0 && at < existing.length ? existing[at] : null;
+      },
+      get length() {
+        return keys().length;
+      }
+    };
+    const storage = new Proxy(api, {
+      get(target, prop, receiver) {
+        if (typeof prop !== "string") return Reflect.get(target, prop, receiver);
+        if (hasOwn(RESERVED, prop)) return Reflect.get(target, prop, receiver);
+        return hasOwn(map, prop) ? map[prop] : void 0;
+      },
+      set(target, prop, value) {
+        if (typeof prop !== "string" || hasOwn(RESERVED, prop)) return true;
+        api.setItem(prop, value);
+        return true;
+      },
+      has(target, prop) {
+        if (typeof prop !== "string") return Reflect.has(target, prop);
+        return hasOwn(RESERVED, prop) || hasOwn(map, prop);
+      },
+      deleteProperty(target, prop) {
+        if (typeof prop === "string" && !hasOwn(RESERVED, prop)) api.removeItem(prop);
+        return true;
+      },
+      ownKeys() {
+        return keys();
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        if (typeof prop !== "string" || !hasOwn(map, prop)) return void 0;
+        return { value: map[prop], writable: true, enumerable: true, configurable: true };
+      }
+    });
+    return {
+      storage,
+      entries: function() {
+        const copy = emptyMap();
+        const existing = keys();
+        for (let i = 0; i < existing.length; i++) copy[existing[i]] = map[existing[i]];
+        return copy;
+      },
+      hydrate: function(values) {
+        for (const key in values) {
+          if (hasOwn(values, key) && !hasOwn(localWrites, key)) map[key] = values[key];
+        }
+      }
+    };
+  }
+  function settled(promise) {
+    return promise.then(
+      function() {
+      },
+      function() {
+      }
+    );
+  }
+  function installSessionStorageShim() {
+    if (nativeStorageWorks("sessionStorage")) return;
+    try {
+      Object.defineProperty(window, "sessionStorage", {
+        value: createStorageShim().storage,
+        configurable: true
+      });
+    } catch (err) {
+    }
+  }
+  function nativeStorageWorks(area) {
+    try {
+      const store = window[area];
+      if (!store) return false;
+      const probe = "__bb_arcade_probe__";
+      store.setItem(probe, "1");
+      store.removeItem(probe);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+  function createStorageController(options) {
+    let shim = null;
+    let mode = "native";
+    let appBlob = null;
+    let hydration = null;
+    let flushTimer = null;
+    let inFlight = Promise.resolve();
+    let dirty = false;
+    let hydrated = false;
+    function serialize() {
+      return buildEnvelope(shim ? shim.entries() : {}, appBlob);
+    }
+    function hydrateFromCloud() {
+      hydration = options.load().then(
+        function(raw) {
+          const envelope = parseEnvelope(raw);
+          if (shim) shim.hydrate(envelope.ls);
+          if (appBlob === null) appBlob = envelope.app;
+          hydrated = true;
+          return mode;
+        },
+        function(err) {
+          const code = err && err.code;
+          if (code === "unsupported" || code === "unauthenticated") mode = "memory";
+          return mode;
+        }
+      );
+      return hydration;
+    }
+    function wouldOverflow(key, value) {
+      if (!shim) return false;
+      const next = shim.entries();
+      next[key] = value;
+      return options.byteLength(buildEnvelope(next, appBlob)) > options.maxBytes;
+    }
+    function persist() {
+      return whenHydrated().then(function() {
+        if (mode === "memory") return;
+        if (hydrated) return options.save(serialize());
+        return hydrateFromCloud().then(function() {
+          if (mode === "memory") return;
+          if (!hydrated) throw storageError("error");
+          return options.save(serialize());
+        });
+      }).then(void 0, function(err) {
+        dirty = true;
+        throw err;
+      });
+    }
+    function flushNow() {
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      dirty = false;
+      const next = inFlight.then(persist, persist);
+      inFlight = settled(next);
+      return next;
+    }
+    function scheduleFlush() {
+      dirty = true;
+      if (flushTimer !== null) return;
+      flushTimer = setTimeout(function() {
+        flushTimer = null;
+        void settled(flushNow());
+      }, FLUSH_DELAY_MS);
+    }
+    function whenHydrated() {
+      return hydration ? hydration : Promise.resolve(mode);
+    }
+    function attachUnloadFlush() {
+      const flushIfDirty = function() {
+        if (dirty) void settled(flushNow());
+      };
+      try {
+        window.addEventListener("pagehide", flushIfDirty);
+        window.addEventListener("visibilitychange", function() {
+          if (document.visibilityState === "hidden") flushIfDirty();
+        });
+      } catch (err) {
+      }
+    }
+    function install() {
+      if (shim) return mode;
+      installSessionStorageShim();
+      if (nativeStorageWorks("localStorage")) {
+        mode = "native";
+        return mode;
+      }
+      const handle = createStorageShim({ onChange: scheduleFlush, wouldOverflow });
+      try {
+        Object.defineProperty(window, "localStorage", {
+          value: handle.storage,
+          configurable: true
+        });
+      } catch (err) {
+        return mode;
+      }
+      shim = handle;
+      mode = "cloud";
+      attachUnloadFlush();
+      void hydrateFromCloud();
+      return mode;
+    }
+    return {
+      install,
+      active: function() {
+        return shim !== null;
+      },
+      ready: function() {
+        return whenHydrated();
+      },
+      flush: function() {
+        if (!shim && appBlob === null) return Promise.resolve();
+        return flushNow();
+      },
+      writeApp: function(blob) {
+        if (options.byteLength(buildEnvelope(shim ? shim.entries() : {}, blob)) > options.maxBytes) {
+          return Promise.reject(storageError("too_large"));
+        }
+        appBlob = blob;
+        return flushNow();
+      },
+      get mode() {
+        return mode;
+      }
+    };
+  }
+
   // src/core.ts
   var BOUNTY_BOARD_URL = "https://www.bountyboard.gg/arcade";
   var ADSENSE_CLIENT_ID = "ca-pub-7727110228190547";
@@ -793,6 +1103,16 @@
       if (!hostnameAllowed(event.origin, DEFAULT_ALLOW)) return;
       applyHostConfig(event.data);
     });
+    const storage = createStorageController({
+      save: function(blob) {
+        return request("save", blob);
+      },
+      load: function() {
+        return request("load");
+      },
+      byteLength: utf8ByteLength,
+      maxBytes: MAX_SAVE_BYTES
+    });
     const sdk = {
       lockToHost,
       init,
@@ -829,11 +1149,15 @@
         if (utf8ByteLength(data) > MAX_SAVE_BYTES) {
           return Promise.reject(sdkError("too_large"));
         }
+        if (storage.active()) return storage.writeApp(data);
         return request("save", data);
       },
       load: function() {
-        return request("load");
+        return request("load").then(function(raw) {
+          return parseEnvelope(raw).app;
+        });
       },
+      storage,
       getPlayer,
       onPlayerChange: function(handler) {
         if (typeof handler !== "function") return function() {
@@ -909,6 +1233,14 @@
       rewardedBreak: () => Promise.resolve(false),
       save: () => Promise.reject(sdkError2("unsupported")),
       load: () => Promise.reject(sdkError2("unsupported")),
+      // No window to shim and nothing to persist to: report the honest mode
+      // rather than pretending an install succeeded.
+      storage: {
+        install: () => "memory",
+        ready: () => Promise.resolve("memory"),
+        flush: () => Promise.resolve(),
+        mode: "memory"
+      },
       getPlayer: () => Promise.resolve(null),
       onPlayerChange: () => () => {
       },
@@ -1020,7 +1352,7 @@
     /** Connect and resolve on the server's welcome (post-ticket-verification). */
     connect(grant) {
       return new Promise((resolve, reject) => {
-        let settled = false;
+        let settled2 = false;
         const url = grant.roomUrl + (grant.roomUrl.indexOf("?") === -1 ? "?" : "&") + "ticket=" + encodeURIComponent(grant.ticket) + (this.joinData === null ? "" : "&join=" + encodeURIComponent(this.joinData));
         const connectStartedAt = Date.now();
         let ws;
@@ -1031,8 +1363,8 @@
         }
         this.ws = ws;
         const welcomeTimer = setTimeout(() => {
-          if (settled) return;
-          settled = true;
+          if (settled2) return;
+          settled2 = true;
           this.pendingConnect = null;
           this.terminal = true;
           try {
@@ -1066,8 +1398,8 @@
             this.connected = true;
             this.reconnectAttempts = 0;
             this.latencyMs = Math.max(0, Date.now() - connectStartedAt);
-            if (!settled) {
-              settled = true;
+            if (!settled2) {
+              settled2 = true;
               this.pendingConnect = null;
               clearTimeout(welcomeTimer);
               resolve(this);
@@ -1107,8 +1439,8 @@
           }
           if (msg.t === "error") {
             const code = String((_e = msg.code) != null ? _e : "error");
-            if (!settled) {
-              settled = true;
+            if (!settled2) {
+              settled2 = true;
               this.terminal = true;
               this.pendingConnect = null;
               clearTimeout(welcomeTimer);
@@ -1125,8 +1457,8 @@
         ws.onclose = (event) => {
           this.connected = false;
           if (event && event.code === SEAT_FULL_CLOSE_CODE) this.terminal = true;
-          if (!settled) {
-            settled = true;
+          if (!settled2) {
+            settled2 = true;
             this.pendingConnect = null;
             clearTimeout(welcomeTimer);
             reject(sdkError3("error"));
@@ -1273,4 +1605,5 @@
   // src/global.ts
   BBArcade.multiplayer = multiplayer;
   window.BBArcade = BBArcade;
+  BBArcade.storage.install();
 })();