@playcademy/sdk 0.1.14 → 0.1.15

package/dist/index.js

@@ -281,6 +281,333 @@ function isInIframe() {
   }
 }
 
+// src/core/connection/monitor.ts
+class ConnectionMonitor {
+  state = "online";
+  callbacks = new Set;
+  heartbeatInterval;
+  consecutiveFailures = 0;
+  isMonitoring = false;
+  config;
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      heartbeatInterval: config.heartbeatInterval ?? 1e4,
+      heartbeatTimeout: config.heartbeatTimeout ?? 5000,
+      failureThreshold: config.failureThreshold ?? 2,
+      enableHeartbeat: config.enableHeartbeat ?? true,
+      enableOfflineEvents: config.enableOfflineEvents ?? true
+    };
+    this._detectInitialState();
+  }
+  start() {
+    if (this.isMonitoring)
+      return;
+    this.isMonitoring = true;
+    if (this.config.enableOfflineEvents && typeof window !== "undefined") {
+      window.addEventListener("online", this._handleOnline);
+      window.addEventListener("offline", this._handleOffline);
+    }
+    if (this.config.enableHeartbeat) {
+      this._startHeartbeat();
+    }
+  }
+  stop() {
+    if (!this.isMonitoring)
+      return;
+    this.isMonitoring = false;
+    if (typeof window !== "undefined") {
+      window.removeEventListener("online", this._handleOnline);
+      window.removeEventListener("offline", this._handleOffline);
+    }
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = undefined;
+    }
+  }
+  onChange(callback) {
+    this.callbacks.add(callback);
+    return () => this.callbacks.delete(callback);
+  }
+  getState() {
+    return this.state;
+  }
+  async checkNow() {
+    await this._performHeartbeat();
+    return this.state;
+  }
+  reportRequestFailure(error) {
+    const isNetworkError = error instanceof TypeError || error instanceof Error && error.message.includes("fetch");
+    if (!isNetworkError)
+      return;
+    this.consecutiveFailures++;
+    if (this.consecutiveFailures >= this.config.failureThreshold) {
+      this._setState("degraded", "Multiple consecutive request failures");
+    }
+  }
+  reportRequestSuccess() {
+    if (this.consecutiveFailures > 0) {
+      this.consecutiveFailures = 0;
+      if (this.state === "degraded") {
+        this._setState("online", "Requests succeeding again");
+      }
+    }
+  }
+  _detectInitialState() {
+    if (typeof navigator !== "undefined" && !navigator.onLine) {
+      this.state = "offline";
+    }
+  }
+  _handleOnline = () => {
+    this.consecutiveFailures = 0;
+    this._setState("online", "Browser online event");
+  };
+  _handleOffline = () => {
+    this._setState("offline", "Browser offline event");
+  };
+  _startHeartbeat() {
+    this._performHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      this._performHeartbeat();
+    }, this.config.heartbeatInterval);
+  }
+  async _performHeartbeat() {
+    if (typeof navigator !== "undefined" && !navigator.onLine) {
+      return;
+    }
+    try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), this.config.heartbeatTimeout);
+      const response = await fetch(`${this.config.baseUrl}/ping`, {
+        method: "GET",
+        signal: controller.signal,
+        cache: "no-store"
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        this.consecutiveFailures = 0;
+        if (this.state !== "online") {
+          this._setState("online", "Heartbeat successful");
+        }
+      } else {
+        this._handleHeartbeatFailure("Heartbeat returned non-OK status");
+      }
+    } catch (error) {
+      this._handleHeartbeatFailure(error instanceof Error ? error.message : "Heartbeat failed");
+    }
+  }
+  _handleHeartbeatFailure(reason) {
+    this.consecutiveFailures++;
+    if (this.consecutiveFailures >= this.config.failureThreshold) {
+      if (typeof navigator !== "undefined" && !navigator.onLine) {
+        this._setState("offline", reason);
+      } else {
+        this._setState("degraded", reason);
+      }
+    }
+  }
+  _setState(newState, reason) {
+    if (this.state === newState)
+      return;
+    const oldState = this.state;
+    this.state = newState;
+    console.debug(`[ConnectionMonitor] ${oldState} → ${newState}: ${reason}`);
+    this.callbacks.forEach((callback) => {
+      try {
+        callback(newState, reason);
+      } catch (error) {
+        console.error("[ConnectionMonitor] Error in callback:", error);
+      }
+    });
+  }
+}
+
+// src/messaging.ts
+class PlaycademyMessaging {
+  listeners = new Map;
+  send(type, payload, options) {
+    if (options?.target) {
+      this.sendViaPostMessage(type, payload, options.target, options.origin || "*");
+      return;
+    }
+    const context = this.getMessagingContext(type);
+    if (context.shouldUsePostMessage) {
+      this.sendViaPostMessage(type, payload, context.target, context.origin);
+    } else {
+      this.sendViaCustomEvent(type, payload);
+    }
+  }
+  listen(type, handler) {
+    const postMessageListener = (event) => {
+      const messageEvent = event;
+      if (messageEvent.data?.type === type) {
+        handler(messageEvent.data.payload || messageEvent.data);
+      }
+    };
+    const customEventListener = (event) => {
+      handler(event.detail);
+    };
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, new Map);
+    }
+    const listenerMap = this.listeners.get(type);
+    listenerMap.set(handler, {
+      postMessage: postMessageListener,
+      customEvent: customEventListener
+    });
+    window.addEventListener("message", postMessageListener);
+    window.addEventListener(type, customEventListener);
+  }
+  unlisten(type, handler) {
+    const typeListeners = this.listeners.get(type);
+    if (!typeListeners || !typeListeners.has(handler)) {
+      return;
+    }
+    const listeners = typeListeners.get(handler);
+    window.removeEventListener("message", listeners.postMessage);
+    window.removeEventListener(type, listeners.customEvent);
+    typeListeners.delete(handler);
+    if (typeListeners.size === 0) {
+      this.listeners.delete(type);
+    }
+  }
+  getMessagingContext(eventType) {
+    const isIframe = typeof window !== "undefined" && window.self !== window.top;
+    const iframeToParentEvents = [
+      "PLAYCADEMY_READY" /* READY */,
+      "PLAYCADEMY_EXIT" /* EXIT */,
+      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */,
+      "PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */,
+      "PLAYCADEMY_DISPLAY_ALERT" /* DISPLAY_ALERT */
+    ];
+    const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
+    return {
+      shouldUsePostMessage,
+      target: shouldUsePostMessage ? window.parent : undefined,
+      origin: "*"
+    };
+  }
+  sendViaPostMessage(type, payload, target = window.parent, origin = "*") {
+    const messageData = { type };
+    if (payload !== undefined) {
+      messageData.payload = payload;
+    }
+    target.postMessage(messageData, origin);
+  }
+  sendViaCustomEvent(type, payload) {
+    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
+  }
+}
+var MessageEvents, messaging;
+var init_messaging = __esm(() => {
+  ((MessageEvents2) => {
+    MessageEvents2["INIT"] = "PLAYCADEMY_INIT";
+    MessageEvents2["TOKEN_REFRESH"] = "PLAYCADEMY_TOKEN_REFRESH";
+    MessageEvents2["PAUSE"] = "PLAYCADEMY_PAUSE";
+    MessageEvents2["RESUME"] = "PLAYCADEMY_RESUME";
+    MessageEvents2["FORCE_EXIT"] = "PLAYCADEMY_FORCE_EXIT";
+    MessageEvents2["OVERLAY"] = "PLAYCADEMY_OVERLAY";
+    MessageEvents2["CONNECTION_STATE"] = "PLAYCADEMY_CONNECTION_STATE";
+    MessageEvents2["READY"] = "PLAYCADEMY_READY";
+    MessageEvents2["EXIT"] = "PLAYCADEMY_EXIT";
+    MessageEvents2["TELEMETRY"] = "PLAYCADEMY_TELEMETRY";
+    MessageEvents2["KEY_EVENT"] = "PLAYCADEMY_KEY_EVENT";
+    MessageEvents2["DISPLAY_ALERT"] = "PLAYCADEMY_DISPLAY_ALERT";
+    MessageEvents2["AUTH_STATE_CHANGE"] = "PLAYCADEMY_AUTH_STATE_CHANGE";
+    MessageEvents2["AUTH_CALLBACK"] = "PLAYCADEMY_AUTH_CALLBACK";
+  })(MessageEvents ||= {});
+  messaging = new PlaycademyMessaging;
+});
+
+// src/core/connection/utils.ts
+function createDisplayAlert(authContext) {
+  return (message, options) => {
+    if (authContext?.isInIframe && typeof window !== "undefined" && window.parent !== window) {
+      window.parent.postMessage({
+        type: "PLAYCADEMY_DISPLAY_ALERT",
+        message,
+        options
+      }, "*");
+    } else {
+      const prefix = options?.type === "error" ? "❌" : options?.type === "warning" ? "⚠️" : "ℹ️";
+      console.log(`${prefix} ${message}`);
+    }
+  };
+}
+
+// src/core/connection/manager.ts
+class ConnectionManager {
+  monitor;
+  authContext;
+  disconnectHandler;
+  connectionChangeCallback;
+  currentState = "online";
+  additionalDisconnectHandlers = new Set;
+  constructor(config) {
+    this.authContext = config.authContext;
+    this.disconnectHandler = config.onDisconnect;
+    this.connectionChangeCallback = config.onConnectionChange;
+    if (config.authContext?.isInIframe) {
+      this._setupPlatformListener();
+    }
+  }
+  getState() {
+    return this.monitor?.getState() ?? this.currentState;
+  }
+  async checkNow() {
+    if (!this.monitor) {
+      return this.currentState;
+    }
+    return await this.monitor.checkNow();
+  }
+  reportRequestSuccess() {
+    this.monitor?.reportRequestSuccess();
+  }
+  reportRequestFailure(error) {
+    this.monitor?.reportRequestFailure(error);
+  }
+  onDisconnect(callback) {
+    this.additionalDisconnectHandlers.add(callback);
+    return () => {
+      this.additionalDisconnectHandlers.delete(callback);
+    };
+  }
+  stop() {
+    this.monitor?.stop();
+  }
+  _setupPlatformListener() {
+    messaging.listen("PLAYCADEMY_CONNECTION_STATE" /* CONNECTION_STATE */, ({ state, reason }) => {
+      this.currentState = state;
+      this._handleConnectionChange(state, reason);
+    });
+  }
+  _handleConnectionChange(state, reason) {
+    this.connectionChangeCallback?.(state, reason);
+    if (state === "offline" || state === "degraded") {
+      const context = {
+        state,
+        reason,
+        timestamp: Date.now(),
+        displayAlert: createDisplayAlert(this.authContext)
+      };
+      if (this.disconnectHandler) {
+        this.disconnectHandler(context);
+      }
+      this.additionalDisconnectHandlers.forEach((handler) => {
+        handler(context);
+      });
+    }
+  }
+}
+var init_manager = __esm(() => {
+  init_messaging();
+});
+
+// src/core/connection/index.ts
+var init_connection = __esm(() => {
+  init_manager();
+});
+
 // src/core/errors.ts
 function extractApiErrorInfo(error) {
   if (!(error instanceof ApiError)) {
@@ -664,100 +991,6 @@ var init_identity = __esm(() => {
   init_login();
 });
 
-// src/messaging.ts
-class PlaycademyMessaging {
-  listeners = new Map;
-  send(type, payload, options) {
-    if (options?.target) {
-      this.sendViaPostMessage(type, payload, options.target, options.origin || "*");
-      return;
-    }
-    const context = this.getMessagingContext(type);
-    if (context.shouldUsePostMessage) {
-      this.sendViaPostMessage(type, payload, context.target, context.origin);
-    } else {
-      this.sendViaCustomEvent(type, payload);
-    }
-  }
-  listen(type, handler) {
-    const postMessageListener = (event) => {
-      const messageEvent = event;
-      if (messageEvent.data?.type === type) {
-        handler(messageEvent.data.payload || messageEvent.data);
-      }
-    };
-    const customEventListener = (event) => {
-      handler(event.detail);
-    };
-    if (!this.listeners.has(type)) {
-      this.listeners.set(type, new Map);
-    }
-    const listenerMap = this.listeners.get(type);
-    listenerMap.set(handler, {
-      postMessage: postMessageListener,
-      customEvent: customEventListener
-    });
-    window.addEventListener("message", postMessageListener);
-    window.addEventListener(type, customEventListener);
-  }
-  unlisten(type, handler) {
-    const typeListeners = this.listeners.get(type);
-    if (!typeListeners || !typeListeners.has(handler)) {
-      return;
-    }
-    const listeners = typeListeners.get(handler);
-    window.removeEventListener("message", listeners.postMessage);
-    window.removeEventListener(type, listeners.customEvent);
-    typeListeners.delete(handler);
-    if (typeListeners.size === 0) {
-      this.listeners.delete(type);
-    }
-  }
-  getMessagingContext(eventType) {
-    const isIframe = typeof window !== "undefined" && window.self !== window.top;
-    const iframeToParentEvents = [
-      "PLAYCADEMY_READY" /* READY */,
-      "PLAYCADEMY_EXIT" /* EXIT */,
-      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */,
-      "PLAYCADEMY_KEY_EVENT" /* KEY_EVENT */
-    ];
-    const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
-    return {
-      shouldUsePostMessage,
-      target: shouldUsePostMessage ? window.parent : undefined,
-      origin: "*"
-    };
-  }
-  sendViaPostMessage(type, payload, target = window.parent, origin = "*") {
-    const messageData = { type };
-    if (payload !== undefined) {
-      messageData.payload = payload;
-    }
-    target.postMessage(messageData, origin);
-  }
-  sendViaCustomEvent(type, payload) {
-    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
-  }
-}
-var MessageEvents, messaging;
-var init_messaging = __esm(() => {
-  ((MessageEvents2) => {
-    MessageEvents2["INIT"] = "PLAYCADEMY_INIT";
-    MessageEvents2["TOKEN_REFRESH"] = "PLAYCADEMY_TOKEN_REFRESH";
-    MessageEvents2["PAUSE"] = "PLAYCADEMY_PAUSE";
-    MessageEvents2["RESUME"] = "PLAYCADEMY_RESUME";
-    MessageEvents2["FORCE_EXIT"] = "PLAYCADEMY_FORCE_EXIT";
-    MessageEvents2["OVERLAY"] = "PLAYCADEMY_OVERLAY";
-    MessageEvents2["READY"] = "PLAYCADEMY_READY";
-    MessageEvents2["EXIT"] = "PLAYCADEMY_EXIT";
-    MessageEvents2["TELEMETRY"] = "PLAYCADEMY_TELEMETRY";
-    MessageEvents2["KEY_EVENT"] = "PLAYCADEMY_KEY_EVENT";
-    MessageEvents2["AUTH_STATE_CHANGE"] = "PLAYCADEMY_AUTH_STATE_CHANGE";
-    MessageEvents2["AUTH_CALLBACK"] = "PLAYCADEMY_AUTH_CALLBACK";
-  })(MessageEvents ||= {});
-  messaging = new PlaycademyMessaging;
-});
-
 // src/core/namespaces/runtime.ts
 function createRuntimeNamespace(client) {
   const eventListeners = new Map;
@@ -2593,7 +2826,7 @@ async function waitForPlaycademyInit(allowedParentOrigins) {
   });
 }
 function createStandaloneConfig() {
-  console.warn("[Playcademy SDK] Standalone mode detected, creating mock context for local development");
+  console.debug("[Playcademy SDK] Standalone mode detected, creating mock context for sandbox development");
   const mockConfig = {
     baseUrl: "http://localhost:4321",
     gameUrl: window.location.origin,
@@ -2618,7 +2851,9 @@ async function init(options) {
     gameUrl: config.gameUrl,
     token: config.token,
     gameId: config.gameId,
-    autoStartSession: window.self !== window.top
+    autoStartSession: window.self !== window.top,
+    onDisconnect: options?.onDisconnect,
+    enableConnectionMonitoring: options?.enableConnectionMonitoring
   });
   client["initPayload"] = config;
   messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, ({ token }) => client.setToken(token));
@@ -2687,6 +2922,7 @@ __export(exports_client, {
 var PlaycademyClient;
 var init_client = __esm(() => {
   init_src();
+  init_connection();
   init_errors();
   init_namespaces();
   init_request();
@@ -2701,6 +2937,7 @@ var init_client = __esm(() => {
     internalClientSessionId;
     authContext;
     initPayload;
+    connectionManager;
     constructor(config) {
       this.baseUrl = config?.baseUrl?.endsWith("/api") ? config.baseUrl : `${config?.baseUrl}/api`;
       this.gameUrl = config?.gameUrl;
@@ -2709,6 +2946,7 @@ var init_client = __esm(() => {
       this.authStrategy = createAuthStrategy(config?.token ?? null, config?.tokenType);
       this._detectAuthContext();
       this._initializeInternalSession().catch(() => {});
+      this._initializeConnectionMonitor();
     }
     getBaseUrl() {
       const isRelative = this.baseUrl.startsWith("/");
@@ -2743,6 +2981,20 @@ var init_client = __esm(() => {
     onAuthChange(callback) {
       this.on("authChange", (payload) => callback(payload.token));
     }
+    onDisconnect(callback) {
+      if (!this.connectionManager) {
+        return () => {};
+      }
+      return this.connectionManager.onDisconnect(callback);
+    }
+    getConnectionState() {
+      return this.connectionManager?.getState() ?? "unknown";
+    }
+    async checkConnection() {
+      if (!this.connectionManager)
+        return "unknown";
+      return await this.connectionManager.checkNow();
+    }
     _setAuthContext(context) {
       this.authContext = context;
     }
@@ -2760,28 +3012,42 @@ var init_client = __esm(() => {
         ...options?.headers,
         ...this.authStrategy.getHeaders()
       };
-      return request({
-        path,
-        method,
-        body: options?.body,
-        baseUrl: this.baseUrl,
-        extraHeaders: effectiveHeaders,
-        raw: options?.raw
-      });
+      try {
+        const result = await request({
+          path,
+          method,
+          body: options?.body,
+          baseUrl: this.baseUrl,
+          extraHeaders: effectiveHeaders,
+          raw: options?.raw
+        });
+        this.connectionManager?.reportRequestSuccess();
+        return result;
+      } catch (error) {
+        this.connectionManager?.reportRequestFailure(error);
+        throw error;
+      }
     }
     async requestGameBackend(path, method, body, headers, raw) {
       const effectiveHeaders = {
         ...headers,
         ...this.authStrategy.getHeaders()
       };
-      return request({
-        path,
-        method,
-        body,
-        baseUrl: this.getGameBackendUrl(),
-        extraHeaders: effectiveHeaders,
-        raw
-      });
+      try {
+        const result = await request({
+          path,
+          method,
+          body,
+          baseUrl: this.getGameBackendUrl(),
+          extraHeaders: effectiveHeaders,
+          raw
+        });
+        this.connectionManager?.reportRequestSuccess();
+        return result;
+      } catch (error) {
+        this.connectionManager?.reportRequestFailure(error);
+        throw error;
+      }
     }
     _ensureGameId() {
       if (!this.gameId) {
@@ -2792,6 +3058,25 @@ var init_client = __esm(() => {
     _detectAuthContext() {
       this.authContext = { isInIframe: isInIframe() };
     }
+    _initializeConnectionMonitor() {
+      if (typeof window === "undefined")
+        return;
+      const isEnabled = this.config.enableConnectionMonitoring ?? true;
+      if (!isEnabled)
+        return;
+      try {
+        this.connectionManager = new ConnectionManager({
+          baseUrl: this.baseUrl,
+          authContext: this.authContext,
+          onDisconnect: this.config.onDisconnect,
+          onConnectionChange: (state, reason) => {
+            this.emit("connectionChange", { state, reason });
+          }
+        });
+      } catch (error) {
+        log.error("[Playcademy SDK] Failed to initialize connection manager:", { error });
+      }
+    }
     async _initializeInternalSession() {
       if (!this.gameId || this.internalClientSessionId)
         return;
@@ -2842,6 +3127,7 @@ var init_client = __esm(() => {
 // src/index.ts
 init_client();
 init_errors();
+init_connection();
 init_messaging();
 export {
   messaging,
@@ -2849,5 +3135,7 @@ export {
   PlaycademyError,
   PlaycademyClient,
   MessageEvents,
+  ConnectionMonitor,
+  ConnectionManager,
   ApiError
 };