@bountyboard/arcade-sdk 1.0.0 → 1.1.0

package/dist/multiplayer.cjs

@@ -67,6 +67,11 @@ function toBoolean(value) {
 function cleanRewardedSize(value) {
   return value === "small" || value === "medium" || value === "large" ? value : "";
 }
+function hasTransientUserActivation() {
+  if (typeof navigator === "undefined") return false;
+  const activation = navigator.userActivation;
+  return (activation == null ? void 0 : activation.isActive) === true;
+}
 function safeCall(fn, arg) {
   if (typeof fn !== "function") return;
   try {
@@ -143,7 +148,7 @@ function sanitizePlayer(value) {
 function createBBArcade() {
   let adPlacementLoad = null;
   let adPreloadConfigured = false;
-  let rewardedBreakActive = false;
+  let rewardedBreakActive = null;
   let rewardedBreakSequence = 0;
   function isLocalAdHost() {
     try {
@@ -554,6 +559,16 @@ function createBBArcade() {
           function show() {
             if (shown) return;
             shown = true;
+            if (!hasTransientUserActivation()) {
+              const activationError = Object.assign(
+                { status: "error", error: "direct_user_action_required" },
+                base
+              );
+              post("rewarded_ad", void 0, Object.assign({ event: "error" }, activationError));
+              safeCall(options.onError, activationError);
+              done(activationError);
+              return;
+            }
             post("rewarded_ad", void 0, Object.assign({ event: "started" }, base));
             try {
               showAdFn();
@@ -577,6 +592,7 @@ function createBBArcade() {
               base
             );
             post("rewarded_ad", void 0, Object.assign({ event: "error" }, beforeError));
+            if (shown) return;
             safeCall(options.onError, beforeError);
             done(beforeError);
           }
@@ -585,9 +601,9 @@ function createBBArcade() {
           adBreak({
             type: "reward",
             name: options.placement,
-            size: options.size || void 0,
             beforeReward: startAd,
             adViewed: function() {
+              if (resolved) return;
               status = "viewed";
               const viewed = Object.assign({ status }, base);
               post("rewarded_ad", void 0, Object.assign({ event: "viewed" }, viewed));
@@ -595,6 +611,7 @@ function createBBArcade() {
               safeCall(options.onReward, viewed);
             },
             adDismissed: function() {
+              if (resolved) return;
               if (status !== "viewed") status = "dismissed";
               const dismissed = Object.assign({ status }, base);
               post("rewarded_ad", void 0, Object.assign({ event: "dismissed" }, dismissed));
@@ -602,6 +619,7 @@ function createBBArcade() {
               safeCall(options.onDismissed, dismissed);
             },
             adBreakDone: function(placementInfo) {
+              if (resolved) return;
               const result = rewardOffered || status !== "unavailable" ? { status } : { status: "unavailable", error: "no_rewarded_ad" };
               if (placementInfo && typeof placementInfo === "object") {
                 result.breakStatus = cleanText(
@@ -635,6 +653,52 @@ function createBBArcade() {
       });
     });
   }
+  function prepareRewardedAd(rawOptions) {
+    const normalized = normalizeRewardedOptions(rawOptions);
+    const base = {
+      placement: normalized.placement,
+      reward: normalized.reward,
+      adBreakId: normalized.adBreakId
+    };
+    if (normalized.size) base.size = normalized.size;
+    let ready2 = false;
+    let finalPromise;
+    return new Promise(function(resolvePreparation) {
+      finalPromise = rewardedAd(
+        Object.assign({}, rawOptions, {
+          // Preserve the id used by the ready handle and every lifecycle event;
+          // rewardedAd normalizes again, but this explicit id keeps both stages
+          // tied to the same placement.
+          adBreakId: normalized.adBreakId,
+          beforeReward: function(showAd) {
+            if (ready2) return;
+            ready2 = true;
+            let shown = false;
+            const prepared = Object.assign(
+              { status: "ready" },
+              base,
+              {
+                show: function() {
+                  if (!shown) {
+                    shown = true;
+                    if (hasTransientUserActivation()) {
+                      safeCall(rawOptions && rawOptions.onStart);
+                    }
+                    showAd();
+                  }
+                  return finalPromise;
+                }
+              }
+            );
+            resolvePreparation(prepared);
+          }
+        })
+      );
+      finalPromise.then(function(result) {
+        if (!ready2) resolvePreparation(result);
+      });
+    });
+  }
   function preloadRewardedAds(rawOptions) {
     const options = normalizeRewardedOptions(rawOptions);
     if (!areRewardedAdsEnabled()) return Promise.resolve(false);
@@ -681,7 +745,7 @@ function createBBArcade() {
       reward: normalized.reward
     };
     if (normalized.size) base.size = normalized.size;
-    if (rewardedBreakActive) {
+    if (rewardedBreakActive && rewardedBreakActive.state !== "ready") {
       post(
         "rewarded_ad",
         void 0,
@@ -692,24 +756,32 @@ function createBBArcade() {
       );
       return Promise.resolve(false);
     }
-    rewardedBreakActive = true;
+    const activeBreak = { state: "loading" };
+    rewardedBreakActive = activeBreak;
     let startCalled = false;
+    const callerBeforeReward = rawOptions.beforeReward;
     return rewardedAd(
       Object.assign({}, rawOptions, {
         beforeReward: function(showAd) {
-          if (startCalled) return;
-          startCalled = true;
-          safeCall(rawOptions.onStart);
-          showAd();
+          if (rewardedBreakActive === activeBreak) activeBreak.state = "ready";
+          const showWithStart = function() {
+            if (startCalled || rewardedBreakActive !== activeBreak) return;
+            startCalled = true;
+            activeBreak.state = "showing";
+            if (hasTransientUserActivation()) safeCall(rawOptions.onStart);
+            showAd();
+          };
+          if (typeof callerBeforeReward === "function") callerBeforeReward(showWithStart);
+          else showWithStart();
         }
       })
     ).then(
       function(result) {
-        rewardedBreakActive = false;
+        if (rewardedBreakActive === activeBreak) rewardedBreakActive = null;
         return Boolean(result && result.status === "viewed");
       },
       function() {
-        rewardedBreakActive = false;
+        if (rewardedBreakActive === activeBreak) rewardedBreakActive = null;
         return false;
       }
     );
@@ -747,6 +819,8 @@ function createBBArcade() {
     },
     rewardedAd,
     showRewardedAd: rewardedAd,
+    prepareRewardedAd,
+    prepareRewardedBreak: prepareRewardedAd,
     rewardedBreak,
     save: function(blob) {
       return request("save", String(blob));
@@ -792,6 +866,13 @@ function createInertBBArcade() {
     reward: "reward",
     adBreakId: "bbad_inert"
   });
+  const prepareUnavailable = () => Promise.resolve({
+    status: "unavailable",
+    error: "ad_break_unavailable",
+    placement: "rewarded",
+    reward: "reward",
+    adBreakId: "bbad_inert"
+  });
   return {
     lockToHost: noop,
     init: () => Promise.resolve(),
@@ -808,6 +889,8 @@ function createInertBBArcade() {
     xrSessionEnd: noop,
     rewardedAd: unavailable,
     showRewardedAd: unavailable,
+    prepareRewardedAd: prepareUnavailable,
+    prepareRewardedBreak: prepareUnavailable,
     rewardedBreak: () => Promise.resolve(false),
     save: () => Promise.reject(sdkError2("unsupported")),
     load: () => Promise.reject(sdkError2("unsupported")),
@@ -826,6 +909,7 @@ var BBArcade = typeof window === "undefined" ? createInertBBArcade() : createBBA
 // src/multiplayer.ts
 var WELCOME_TIMEOUT_MS = 1e4;
 var MAX_RECONNECT_ATTEMPTS = 3;
+var MAX_JOIN_DATA_BYTES = 1024;
 var CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 var CODE_LENGTH = 4;
 function sdkError3(code) {
@@ -847,15 +931,42 @@ function randomChars(length) {
 function generateCode() {
   return randomChars(CODE_LENGTH);
 }
-var guestKey = null;
-function getGuestKey() {
-  if (!guestKey) guestKey = randomChars(16);
-  return guestKey;
+function utf8ByteLength(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code <= 56319 && i + 1 < value.length) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i += 1;
+      } else {
+        bytes += 3;
+      }
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function serializeJoinData(data) {
+  if (data === void 0) return null;
+  if (!data || typeof data !== "object" || Array.isArray(data)) throw sdkError3("rejected");
+  let serialized;
+  try {
+    serialized = JSON.stringify(data);
+  } catch (e) {
+    throw sdkError3("rejected");
+  }
+  if (!serialized || utf8ByteLength(serialized) > MAX_JOIN_DATA_BYTES) {
+    throw sdkError3("rejected");
+  }
+  return serialized;
 }
 function requestTicket(roomId) {
   const request = BBArcade._request;
   if (typeof request !== "function") return Promise.reject(sdkError3("unsupported"));
-  return request("mp_ticket", { roomId, guestKey: getGuestKey() }).then((grant) => {
+  return request("mp_ticket", { roomId }).then((grant) => {
     const g = grant;
     if (!g || typeof g.ticket !== "string" || typeof g.roomUrl !== "string") {
       throw sdkError3("error");
@@ -864,10 +975,11 @@ function requestTicket(roomId) {
   });
 }
 var RoomConnection = class {
-  constructor(code, devGrant) {
+  constructor(code, devGrant, joinData) {
     this.playerId = "";
     this.players = [];
     this.state = null;
+    this.connected = false;
     this.ws = null;
     // Keyed by event name; values are erased to (unknown) => void internally and
     // retyped at the on()/emit() boundary, which keeps the public API strictly
@@ -882,12 +994,13 @@ var RoomConnection = class {
     this.reconnectAttempts = 0;
     this.code = code;
     this.devGrant = devGrant;
+    this.joinData = joinData;
   }
   /** Connect and resolve on the server's welcome (post-ticket-verification). */
   connect(grant) {
     return new Promise((resolve, reject) => {
       let settled = false;
-      const url = grant.roomUrl + (grant.roomUrl.indexOf("?") === -1 ? "?" : "&") + "ticket=" + encodeURIComponent(grant.ticket);
+      const url = grant.roomUrl + (grant.roomUrl.indexOf("?") === -1 ? "?" : "&") + "ticket=" + encodeURIComponent(grant.ticket) + (this.joinData === null ? "" : "&join=" + encodeURIComponent(this.joinData));
       let ws;
       try {
         ws = new WebSocket(url);
@@ -915,15 +1028,18 @@ var RoomConnection = class {
         }
         if (!msg || typeof msg.t !== "string") return;
         if (msg.t === "welcome") {
+          const reconnected = this.reconnectAttempts > 0;
           this.playerId = String((_a = msg.playerId) != null ? _a : "");
           this.players = Array.isArray(msg.players) ? msg.players : [];
           this.state = (_b = msg.state) != null ? _b : null;
+          this.connected = true;
           this.reconnectAttempts = 0;
           if (!settled) {
             settled = true;
             clearTimeout(welcomeTimer);
             resolve(this);
           }
+          if (reconnected) this.emit("connection", { connected: true, reconnecting: false });
           return;
         }
         if (msg.t === "snapshot") {
@@ -973,6 +1089,7 @@ var RoomConnection = class {
         }
       };
       ws.onclose = () => {
+        this.connected = false;
         if (!settled) {
           settled = true;
           clearTimeout(welcomeTimer);
@@ -980,6 +1097,7 @@ var RoomConnection = class {
           return;
         }
         if (this.intentionalClose || this.ended || this.terminal) {
+          this.emit("connection", { connected: false, reconnecting: false });
           this.emit("close", { reconnecting: false });
           return;
         }
@@ -997,6 +1115,7 @@ var RoomConnection = class {
       return;
     }
     this.reconnectAttempts += 1;
+    this.emit("connection", { connected: false, reconnecting: true });
     this.emit("close", { reconnecting: true });
     await new Promise((r) => setTimeout(r, 400 * this.reconnectAttempts));
     if (this.intentionalClose || this.ended || this.terminal) return;
@@ -1010,11 +1129,16 @@ var RoomConnection = class {
     }
   }
   send(input) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.trySend(input);
+  }
+  trySend(input) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return false;
     this.seq += 1;
     try {
       this.ws.send(JSON.stringify({ t: "input", seq: this.seq, data: input }));
+      return true;
     } catch (err) {
+      return false;
     }
   }
   on(event, handler) {
@@ -1030,6 +1154,7 @@ var RoomConnection = class {
   leave() {
     var _a;
     this.intentionalClose = true;
+    this.connected = false;
     try {
       (_a = this.ws) == null ? void 0 : _a.close(1e3);
     } catch (err) {
@@ -1055,11 +1180,17 @@ function joinRoom(options) {
     return Promise.reject(sdkError3("unsupported"));
   }
   const code = opts.create || !opts.code ? generateCode() : opts.code.toUpperCase();
+  let joinData;
+  try {
+    joinData = serializeJoinData(opts.joinData);
+  } catch (err) {
+    return Promise.reject(err);
+  }
   if (opts.roomUrl && opts.ticket) {
     const devGrant = { ticket: opts.ticket, roomUrl: opts.roomUrl, expiresAt: 0 };
-    return new RoomConnection(code, devGrant).connect(devGrant);
+    return new RoomConnection(code, devGrant, joinData).connect(devGrant);
   }
-  return requestTicket(code).then((grant) => new RoomConnection(code, null).connect(grant));
+  return requestTicket(code).then((grant) => new RoomConnection(code, null, joinData).connect(grant));
 }
 var multiplayer = { joinRoom };
 // Annotate the CommonJS export names for ESM import in node: