@looplay/sdk 0.8.5 → 0.8.7

package/dist/looplay-sdk.cjs.js

@@ -139,6 +139,9 @@ var LooplayAuth = class {
   }
 };
 
+// src/version.ts
+var LOOPLAY_SDK_VERSION = "0.8.5";
+
 // src/apps/http.ts
 function getFetchFn(fetchOverride) {
   if (fetchOverride) {
@@ -166,7 +169,10 @@ var HttpClient = class {
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
     this.fetchFn = getFetchFn(options.fetch);
-    this.defaultHeaders = options.defaultHeaders ?? {};
+    this.defaultHeaders = {
+      "x-looplay-sdk-version": LOOPLAY_SDK_VERSION,
+      ...options.defaultHeaders ?? {}
+    };
   }
   async request(method, path, options) {
     const url = this.buildUrl(path, options?.query);
@@ -269,6 +275,19 @@ var ServiceClient = class {
       body
     });
   }
+  /**
+   * Re-issues a fresh `playSessionToken` for the SAME `playSessionId` — call
+   * this instead of `startPlaySession` when refreshing an about-to-expire
+   * (or just-expired, within the server's renewal grace window) token, so
+   * long-running sessions keep a single `playSessionId` throughout.
+   */
+  async renewPlaySession(gameKey, auth = {}, body) {
+    return this.http.request("POST", "/sdk/games/play-sessions/renew", {
+      ...auth,
+      headers: { "x-game-key": gameKey, ...this.trackingHeaders(auth) },
+      body
+    });
+  }
   async completePlaySession(gameKey, auth, body) {
     await this.http.request("POST", "/sdk/games/play-sessions/complete", {
       ...auth,
@@ -438,9 +457,11 @@ var ApiClient = class {
   getAccessToken;
   getAnonymousId;
   trackingSession;
+  trackingSessionPromiseKey;
   trackingSessionPromise;
   currentPlaySessionId;
   playSession;
+  playSessionPromiseKey;
   playSessionPromise;
   constructor(options) {
     if (!options.baseUrl) throw new MissingBaseUrlError();
@@ -481,7 +502,10 @@ var ApiClient = class {
     const bearerToken = await this.getAccessToken?.();
     const anonId = bearerToken ? void 0 : this.getAnonymousId?.();
     if (!bearerToken && !anonId) throw new NotAuthenticatedError();
-    const session = await this.ensureTrackingSession(anonId);
+    const session = await this.ensureTrackingSession(
+      bearerToken ? `bearer:${bearerToken}` : `anon:${anonId}`,
+      anonId
+    );
     return {
       bearerToken,
       anonId,
@@ -494,14 +518,16 @@ var ApiClient = class {
    * session. Swallows failures — tracking calls still work without it,
    * just without unified session tracing.
    */
-  async ensureTrackingSession(anonId) {
+  async ensureTrackingSession(cacheKey, anonId) {
     const now = Date.now();
-    if (this.trackingSession && this.trackingSession.expiresAtMs > now + 3e4) {
+    if (this.trackingSession && this.trackingSession.cacheKey === cacheKey && this.trackingSession.expiresAtMs > now + 3e4) {
       return this.trackingSession;
     }
-    if (!this.trackingSessionPromise) {
+    if (!this.trackingSessionPromise || this.trackingSessionPromiseKey !== cacheKey) {
+      this.trackingSessionPromiseKey = cacheKey;
       this.trackingSessionPromise = this.raw.bootstrapTrackingSession(anonId).then((dto) => {
         this.trackingSession = {
+          cacheKey,
           trackingSessionId: dto.trackingSessionId,
           anonTrackingToken: dto.trackingToken,
           expiresAtMs: new Date(dto.expiresAt).getTime()
@@ -509,10 +535,18 @@ var ApiClient = class {
         return this.trackingSession;
       }).catch(() => void 0).finally(() => {
         this.trackingSessionPromise = void 0;
+        this.trackingSessionPromiseKey = void 0;
       });
     }
     return this.trackingSessionPromise;
   }
+  getTrackingAuthKey(auth) {
+    return [
+      auth.bearerToken ? `bearer:${auth.bearerToken}` : `anon:${auth.anonId ?? ""}`,
+      auth.trackingSessionId ?? "",
+      auth.anonTrackingToken ?? ""
+    ].join("\n");
+  }
   /**
    * Signs (and caches until near expiry) the `playSessionToken` required by
    * `trackPlay`/`trackMatch`/`emit` for the current play session — does not
@@ -521,12 +555,20 @@ var ApiClient = class {
    */
   async ensurePlaySession(gameKey, auth, playSessionId) {
     const now = Date.now();
-    if (this.playSession && this.playSession.gameKey === gameKey && this.playSession.playSessionId === playSessionId && this.playSession.expiresAtMs > now + 1e4) {
+    const cacheKey = [gameKey, playSessionId, this.getTrackingAuthKey(auth)].join("\n");
+    if (this.playSession && this.playSession.cacheKey === cacheKey && this.playSession.gameKey === gameKey && this.playSession.playSessionId === playSessionId && this.playSession.expiresAtMs > now + 1e4) {
       return this.playSession;
     }
-    if (!this.playSessionPromise) {
-      this.playSessionPromise = this.raw.startPlaySession(gameKey, auth, { playSessionId }).then((dto) => {
+    const previous = this.playSession && this.playSession.cacheKey === cacheKey && this.playSession.gameKey === gameKey && this.playSession.playSessionId === playSessionId ? this.playSession : void 0;
+    if (!this.playSessionPromise || this.playSessionPromiseKey !== cacheKey) {
+      this.playSessionPromiseKey = cacheKey;
+      const issue = previous ? this.raw.renewPlaySession(gameKey, auth, {
+        playSessionId,
+        playSessionToken: previous.playSessionToken
+      }).catch(() => this.raw.startPlaySession(gameKey, auth, { playSessionId })) : this.raw.startPlaySession(gameKey, auth, { playSessionId });
+      this.playSessionPromise = issue.then((dto) => {
         this.playSession = {
+          cacheKey,
           gameKey,
           playSessionId: dto.playSessionId,
           playSessionToken: dto.playSessionToken,
@@ -535,6 +577,7 @@ var ApiClient = class {
         return this.playSession;
       }).finally(() => {
         this.playSessionPromise = void 0;
+        this.playSessionPromiseKey = void 0;
       });
     }
     return this.playSessionPromise;
@@ -885,6 +928,7 @@ var LooplayIframeAuth = class {
   initialized = false;
   lifecycleTrackingInitialized = false;
   lastGameStartedKey = null;
+  integrationDetectionKeys = /* @__PURE__ */ new Set();
   client = null;
   listeners = /* @__PURE__ */ new Set();
   options;
@@ -986,6 +1030,7 @@ var LooplayIframeAuth = class {
   init() {
     if (this.initialized || typeof window === "undefined") return;
     this.initialized = true;
+    void this.detectIntegrationOnce();
     const isEmbedded = window.parent !== window;
     this.debug("auth listener initialized", {
       isIframe: isEmbedded,
@@ -1036,6 +1081,7 @@ var LooplayIframeAuth = class {
     this.anonymousFallbackTimer = null;
     this.initialized = false;
     this.lifecycleTrackingInitialized = false;
+    this.integrationDetectionKeys.clear();
     this.listeners.clear();
   }
   /** Lazily builds (and rebuilds on auth change) the `ApiClient` bound to the current auth mode. */
@@ -1104,7 +1150,15 @@ var LooplayIframeAuth = class {
     this.debug("emitGameEvent dispatched", { gameId, actionCode, ...opts });
     return this.getClient().emit(gameId, actionCode, opts);
   }
-  /** Idempotent; auto-emits GAME_STARTED exactly once per distinct auth session (bearer or anonymous). */
+  /**
+   * Idempotent; auto-emits GAME_STARTED exactly once per distinct auth
+   * session (bearer or anonymous), and self-reports SDK integration the
+   * same way the standalone `LooplaySDK.init()` does — without this, games
+   * embedded via iframe never trigger the active detect call, only the
+   * passive heartbeat that tracking calls leave behind (which doesn't fire
+   * at all while the game is still IN_REVIEW/not LIVE, since tracking is
+   * blocked until then).
+   */
   initLifecycleTracking() {
     if (this.lifecycleTrackingInitialized || typeof window === "undefined")
       return;
@@ -1114,6 +1168,11 @@ var LooplayIframeAuth = class {
       const key = this.getTrackingKey();
       if (!key || this.lastGameStartedKey === key) return;
       this.lastGameStartedKey = key;
+      const gameId = this.getGameId();
+      if (gameId) {
+        this.debug("auto detectIntegration dispatch", { gameId });
+        void this.getClient().detectIntegration(gameId).catch(() => void 0);
+      }
       this.debug("auto GAME_STARTED dispatch");
       void this.emitGameEvent("GAME_STARTED");
     });
@@ -1233,8 +1292,11 @@ ${identity}`;
     }
   }
   setState(next) {
+    const currentApiUrl = this.getApiUrl();
     this.state = next;
-    this.client = null;
+    if (this.getApiUrl() !== currentApiUrl) {
+      this.client = null;
+    }
     this.debug("auth state updated", {
       gameId: this.getGameId(),
       apiUrl: this.getApiUrl(),
@@ -1243,6 +1305,28 @@ ${identity}`;
       hasAnonymousId: Boolean(next.anonymousId)
     });
     this.listeners.forEach((listener) => listener(next));
+    void this.detectIntegrationOnce();
+  }
+  /** Detects each resolved game/API pair at most once for this iframe session. */
+  async detectIntegrationOnce() {
+    const gameId = this.getGameId();
+    const apiUrl = this.getApiUrl();
+    if (!gameId || !apiUrl) return;
+    const key = `${apiUrl}
+${gameId}`;
+    if (this.integrationDetectionKeys.has(key)) return;
+    this.integrationDetectionKeys.add(key);
+    try {
+      await this.getClient().detectIntegration(gameId);
+      this.debug("integration detected", { gameId, apiUrl });
+    } catch (error) {
+      this.integrationDetectionKeys.delete(key);
+      this.debug("integration detection failed", {
+        gameId,
+        apiUrl,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
   resolveParentOrigin() {
     if (this.options.parentOrigin) return this.options.parentOrigin;
@@ -1291,6 +1375,7 @@ exports.ApiClient = ApiClient;
 exports.BrowserLocalStorageAuthStorage = BrowserLocalStorageAuthStorage;
 exports.HttpClient = HttpClient;
 exports.HttpError = HttpError;
+exports.LOOPLAY_SDK_VERSION = LOOPLAY_SDK_VERSION;
 exports.LooplayAuth = LooplayAuth;
 exports.LooplayIframeAuth = LooplayIframeAuth;
 exports.LooplaySDK = LooplaySDK;