@series-inc/venus-sdk 2.4.1 → 2.6.2

package/dist/{chunk-KQZIPQLJ.mjs → chunk-YDXFZ2A2.mjs}

@@ -1,4 +1,219 @@
-import { __publicField, createMockDelay, MOCK_DELAYS, isWebPlatform } from './chunk-MWUS3A7C.mjs';
+import { __esm, __export, __publicField, createMockDelay, MOCK_DELAYS, isWebPlatform } from './chunk-W7IPHM67.mjs';
+
+// src/rooms/VenusRoom.ts
+var VenusRoom;
+var init_VenusRoom = __esm({
+  "src/rooms/VenusRoom.ts"() {
+    VenusRoom = class {
+      constructor(roomData) {
+        __publicField(this, "id");
+        __publicField(this, "name");
+        __publicField(this, "players");
+        __publicField(this, "maxPlayers");
+        __publicField(this, "gameType");
+        __publicField(this, "appId");
+        __publicField(this, "type");
+        __publicField(this, "createdBy");
+        __publicField(this, "createdAt");
+        __publicField(this, "updatedAt");
+        __publicField(this, "isPrivate");
+        __publicField(this, "currentPlayers");
+        __publicField(this, "status");
+        __publicField(this, "customMetadata");
+        __publicField(this, "admins");
+        __publicField(this, "roomCode");
+        __publicField(this, "description");
+        __publicField(this, "data");
+        __publicField(this, "version");
+        __publicField(this, "_subscriptions", /* @__PURE__ */ new Map());
+        this.id = roomData.id;
+        this.name = roomData.name;
+        this.players = roomData.currentPlayers || [];
+        this.maxPlayers = roomData.maxPlayers;
+        this.gameType = roomData.gameType;
+        this.appId = roomData.appId;
+        this.type = roomData.type;
+        this.createdBy = roomData.createdBy;
+        this.createdAt = roomData.createdAt;
+        this.updatedAt = roomData.updatedAt;
+        this.isPrivate = roomData.isPrivate;
+        this.currentPlayers = roomData.currentPlayers || [];
+        this.status = roomData.status;
+        this.customMetadata = roomData.customMetadata || {};
+        this.admins = roomData.admins || [];
+        this.roomCode = roomData.roomCode;
+        this.description = roomData.description;
+        this.data = roomData.data || {};
+        this.version = roomData.version;
+        console.log(`VenusRoom: Created room object for ${this.id}`, {
+          hasCustomMetadata: !!this.customMetadata,
+          hasGameState: !!this.customMetadata?.rules?.gameState,
+          gamePhase: this.customMetadata?.rules?.gameState?.phase,
+          currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
+        });
+      }
+      updateFromRoomData(newRoomData) {
+        if (newRoomData.id === this.id) {
+          this.name = newRoomData.name || this.name;
+          this.players = newRoomData.currentPlayers || this.players;
+          this.maxPlayers = newRoomData.maxPlayers || this.maxPlayers;
+          this.gameType = newRoomData.gameType || this.gameType;
+          this.currentPlayers = newRoomData.currentPlayers || this.currentPlayers;
+          this.customMetadata = newRoomData.customMetadata || this.customMetadata;
+          this.data = newRoomData.data || this.data;
+          this.status = newRoomData.status || this.status;
+          this.updatedAt = newRoomData.updatedAt || this.updatedAt;
+          console.log(`VenusRoom: Updated room object ${this.id} with fresh data`, {
+            hasCustomMetadata: !!this.customMetadata,
+            hasGameState: !!this.customMetadata?.rules?.gameState,
+            gamePhase: this.customMetadata?.rules?.gameState?.phase,
+            currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rooms/RoomsApi.ts
+var init_RoomsApi = __esm({
+  "src/rooms/RoomsApi.ts"() {
+  }
+});
+
+// src/rooms/index.ts
+var rooms_exports = {};
+__export(rooms_exports, {
+  VenusRoom: () => VenusRoom,
+  initializeRoomsApi: () => initializeRoomsApi,
+  setupRoomNotifications: () => setupRoomNotifications
+});
+function bindMethod(target, targetKey, source, sourceKey) {
+  const key = sourceKey ?? targetKey;
+  const fn = source?.[key];
+  if (typeof fn === "function") {
+    target[targetKey] = fn.bind(source);
+    return true;
+  }
+  return false;
+}
+function setupRoomNotifications(transport, getSubscriptions) {
+  console.log("[Venus Rooms] Setting up room notification listeners");
+  return transport.onVenusMessage((message) => {
+    const subscriptions = getSubscriptions();
+    if (!subscriptions) {
+      return;
+    }
+    if (message.type === "H5_ROOM_DATA_UPDATED") {
+      const messageData = message.data;
+      const { roomId, roomData } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.data?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Room data updated for ${roomId}, notifying ${callbacks.length} callbacks`, roomData);
+      callbacks.forEach((callback) => {
+        try {
+          callback(roomData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in room data callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+    if (message.type === "H5_ROOM_MESSAGE_RECEIVED" || message.type === "H5_ROOM_MESSAGE_UPDATED" || message.type === "H5_ROOM_MESSAGE_DELETED") {
+      const messageData = message.data;
+      const { roomId } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.messages?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Room message event for ${roomId}, notifying ${callbacks.length} callbacks`);
+      callbacks.forEach((callback) => {
+        try {
+          callback(messageData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in room message callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+    if (message.type === "app:h5:proposedMoveValidationUpdated") {
+      const messageData = message.data;
+      const { roomId } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.gameEvents?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Proposed move validation updated for ${roomId}, notifying ${callbacks.length} callbacks`);
+      callbacks.forEach((callback) => {
+        try {
+          callback(messageData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in game event callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+  });
+}
+function initializeRoomsApi(venusApi, host) {
+  const roomsApi = host?.rooms;
+  if (!roomsApi) {
+    console.warn(
+      "[Venus SDK] Host did not provide a rooms implementation. Rooms API will be unavailable."
+    );
+    return;
+  }
+  const venus = venusApi;
+  const existingNamespace = venus.rooms || {};
+  const roomsNamespace = Object.assign({}, existingNamespace);
+  const namespaceBindings = [
+    ["create", "createRoom"],
+    ["joinOrCreate", "joinOrCreateRoom"],
+    ["joinByCode", "joinRoomByCode"],
+    ["list", "getUserRooms"],
+    ["subscribeToRoom", "subscribe"],
+    ["updateRoomData", "updateData"],
+    ["getRoomData", "getData"],
+    ["sendRoomMessage", "sendMessage"],
+    ["leaveRoom", "leave"],
+    ["startRoomGame", "startGame"],
+    ["proposeMove"],
+    ["validateMove"]
+  ];
+  namespaceBindings.forEach(([targetKey, sourceKey]) => {
+    bindMethod(roomsNamespace, targetKey, roomsApi, sourceKey);
+  });
+  venus.rooms = roomsNamespace;
+}
+var init_rooms = __esm({
+  "src/rooms/index.ts"() {
+    init_RoomsApi();
+    init_VenusRoom();
+  }
+});
 
 // src/VenusMessageId.ts
 var VenusMessageId = /* @__PURE__ */ ((VenusMessageId2) => {
@@ -115,6 +330,10 @@ var VenusMessageId = /* @__PURE__ */ ((VenusMessageId2) => {
   VenusMessageId2["H5_ROOM_ELIMINATE_PLAYER"] = "H5_ROOM_ELIMINATE_PLAYER";
   VenusMessageId2["H5_ROOM_PROMOTE_TO_SPECTATOR"] = "H5_ROOM_PROMOTE_TO_SPECTATOR";
   VenusMessageId2["H5_LOAD_EMBEDDED_ASSET"] = "H5_LOAD_EMBEDDED_ASSET";
+  VenusMessageId2["H5_SHOW_LOAD_SCREEN"] = "H5_SHOW_LOAD_SCREEN";
+  VenusMessageId2["H5_HIDE_LOAD_SCREEN"] = "H5_HIDE_LOAD_SCREEN";
+  VenusMessageId2["H5_SET_LOADER_TEXT"] = "H5_SET_LOADER_TEXT";
+  VenusMessageId2["H5_SET_LOADER_PROGRESS"] = "H5_SET_LOADER_PROGRESS";
   VenusMessageId2["H5_IAP_OPEN_STORE"] = "H5_IAP_OPEN_STORE";
   VenusMessageId2["H5_IAP_GET_CURRENCY_ICON"] = "H5_IAP_GET_CURRENCY_ICON";
   return VenusMessageId2;
@@ -136,7 +355,11 @@ var RpcAdsApi = class {
     return response.shown;
   }
   async isRewardedAdReadyAsync() {
-    return true;
+    console.log(`[Venus SDK] [RpcAdsApi] isRewardedAdReadyAsync`);
+    const response = await this.rpcClient.call(
+      "H5_IS_REWARDED_AD_READY" /* IS_REWARDED_AD_READY */
+    );
+    return response.ready;
   }
   async showRewardedAdAsync() {
     console.log("[Venus SDK] [RpcAdsApi] showRewardedAdAsync");
@@ -173,6 +396,8 @@ var MockAdsApi = class {
   }
   async showInterstitialAd() {
     this.log(`[MockAdsApi] showInterstitialAd`);
+    await this.mockOverlay.showAdOverlay();
+    this.log("[MockAdsApi] interstitial ad shown");
     return true;
   }
   log(message, ...args) {
@@ -1537,7 +1762,7 @@ var MockNotificationsApi = class {
     __publicField(this, "venusApi");
     this.venusApi = venusApi;
   }
-  async cancelLocalNotification(notificationId) {
+  async cancelNotification(notificationId) {
     const venusApi = this.venusApi;
     if (isWebPlatform()) {
       console.log(
@@ -1578,16 +1803,16 @@ var MockNotificationsApi = class {
     const isEnabled = venusApi._mock.notificationsEnabled !== false;
     return isEnabled;
   }
-  async scheduleLocalNotification(title, body, options) {
+  async scheduleAsync(options) {
     if (isWebPlatform()) {
       console.log(
         "[Venus Mock] Notifications not supported on web platform, simulating success"
       );
       console.info(
         "\u{1F514} [Venus Mock] Notification would be scheduled:",
-        title || "Untitled",
+        options.title || "Untitled",
         "\n   Body:",
-        body || "No body",
+        options.body || "No body",
         "\n   This is a simulation - real notifications require a native platform."
       );
       const mockId = `mock-web-notification-${Date.now()}`;
@@ -1608,9 +1833,11 @@ var MockNotificationsApi = class {
         venusApi._mock.scheduledNotifications = {};
       }
       venusApi._mock.scheduledNotifications[notificationId] = {
-        ...options,
         id: notificationId,
-        createdAt: Date.now()
+        title: options.title,
+        body: options.body,
+        payload: options.payload,
+        trigger: options.trigger
       };
       setTimeout(() => {
         resolve(notificationId);
@@ -1633,36 +1860,76 @@ var MockNotificationsApi = class {
   }
 };
 
-// src/notifications/index.ts
-function initializeLocalNotifications(venusApi, host) {
-  venusApi.setLocalNotifEnabledAsync = async (enable) => {
-    await host.notifications.setLocalNotificationsEnabled(enable);
-  };
-  venusApi.isLocalNotifEnabledAsync = async () => {
-    return host.notifications.isLocalNotificationsEnabled();
-  };
-  venusApi.getAllLocalNotifsAsync = async () => {
-    return host.notifications.getAllScheduledLocalNotifications();
-  };
-  venusApi.cancelLocalNotifAsync = async (notificationId) => {
-    await host.notifications.cancelLocalNotification(notificationId);
-  };
-  venusApi.scheduleLocalNotifAsync = async (options) => {
-    const id = await host.notifications.scheduleLocalNotification(
-      options.title,
-      options.body,
+// src/notifications/RpcNotificationsApi.ts
+var RpcNotificationsApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async scheduleAsync(options) {
+    const request = {
+      title: options.title,
+      body: options.body,
+      data: options.payload,
+      key: options.groupId,
+      priority: options.priority || 1,
+      trigger: options.trigger
+    };
+    const response = await this.rpcClient.call(
+      "H5_SCHEDULE_LOCAL_NOTIFICATION" /* SCHEDULE_LOCAL_NOTIFICATION */,
+      request
+    );
+    if (response.scheduled) {
+      return response.id;
+    }
+    return null;
+  }
+  async cancelNotification(id) {
+    const result = await this.rpcClient.call(
+      "H5_CANCEL_LOCAL_NOTIFICATION" /* CANCEL_LOCAL_NOTIFICATION */,
       {
-        trigger: options.trigger,
-        priority: options.priority,
-        groupId: options.groupId,
-        payload: options.payload
+        id
       }
     );
-    if (id) {
-      return id;
-    }
-    return "";
-  };
+    return result.canceled;
+  }
+  async getAllScheduledLocalNotifications() {
+    const response = await this.rpcClient.call(
+      "H5_GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS" /* GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS */,
+      {}
+    );
+    const notifications = response.notifications.map((notif) => {
+      return {
+        id: notif.identifier,
+        title: notif.content.title,
+        body: notif.content.body,
+        payload: notif.content.data,
+        trigger: notif.trigger
+      };
+    });
+    return notifications;
+  }
+  async isLocalNotificationsEnabled() {
+    const response = await this.rpcClient.call(
+      "H5_IS_LOCAL_NOTIFICATIONS_ENABLED" /* IS_LOCAL_NOTIFICATIONS_ENABLED */,
+      {}
+    );
+    return response.enabled;
+  }
+  async setLocalNotificationsEnabled(enabled) {
+    const response = await this.rpcClient.call(
+      "H5_SET_LOCAL_NOTIFICATIONS_ENABLED" /* SET_LOCAL_NOTIFICATIONS_ENABLED */,
+      {
+        enabled
+      }
+    );
+    return response.enabled;
+  }
+};
+
+// src/notifications/index.ts
+function initializeLocalNotifications(venusApi, host) {
+  venusApi.notifications = host.notifications;
 }
 
 // src/popups/RpcPopupsApi.ts
@@ -1810,17 +2077,22 @@ function initializePopups(venusApi, host) {
 // src/profile/HostProfileApi.ts
 var HostProfileApi = class {
   getCurrentProfile() {
-    if (window.venus._config && window.venus._config.profile) {
-      return {
-        id: window.venus._config.profile.id || "unknown",
-        name: window.venus._config.profile.username || "Unknown User",
-        username: window.venus._config.profile.username || "unknown"
-      };
+    const profile = window.venus?.profile;
+    if (!profile) {
+      throw new Error(
+        "[Venus SDK] Host profile handshake did not complete. Await VenusAPI.initializeAsync() so INIT_SDK can deliver the profile before calling profile APIs."
+      );
+    }
+    if (!profile.id || !profile.username) {
+      throw new Error(
+        "[Venus SDK] INIT_SDK returned an incomplete profile (missing id/username). The host must supply real credentials before rooms APIs are used."
+      );
     }
     return {
-      id: "mock_profile_123",
-      name: "Mock User",
-      username: "mockuser"
+      id: profile.id,
+      username: profile.username,
+      avatarUrl: profile.avatarUrl,
+      isAnonymous: profile.isAnonymous
     };
   }
 };
@@ -1831,7 +2103,8 @@ var MockProfileApi = class {
     return {
       id: "mock_profile_123",
       name: "Mock User",
-      username: "mockuser"
+      username: "mockuser",
+      isAnonymous: false
     };
   }
 };
@@ -3276,7 +3549,7 @@ function initializeTime(venusApi, host) {
 }
 
 // src/version.ts
-var SDK_VERSION = "2.4.1";
+var SDK_VERSION = "2.6.2";
 
 // src/shared-assets/consts.ts
 var BurgerTimeAssetsCdnPath = "burger-time/Core.stow";
@@ -3347,6 +3620,47 @@ var MockSharedAssetsApi = class {
   }
 };
 
-export { HapticFeedbackStyle, HostCdnApi, HostProfileApi, HostTimeApi, MockAdsApi, MockAiApi, MockAnalyticsApi, MockAvatarApi, MockCdnApi, MockFeaturesApi, MockHapticsApi, MockIapApi, MockLifecycleApi, MockLoggingApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockProfileApi, MockSharedAssetsApi, MockSimulationApi, MockStorageApi, MockTimeApi, RpcAdsApi, RpcAiApi, RpcAnalyticsApi, RpcAvatarApi, RpcClient, RpcFeaturesApi, RpcHapticsApi, RpcIapApi, RpcLifecycleApi, RpcLoggingApi, RpcNavigationApi, RpcPopupsApi, RpcSharedAssetsApi, RpcSimulationApi, RpcStorageApi, SDK_VERSION, VenusMessageId, createMockStorageApi, initializeAds, initializeAi, initializeAnalytics, initializeAvatar3d, initializeCdn, initializeFeaturesApi, initializeHaptics, initializeIap, initializeLifecycleApi, initializeLocalNotifications, initializeLoggingApi, initializePopups, initializeProfile, initializeSimulation, initializeStackNavigation, initializeStorage, initializeTime, isPacificDaylightTime };
-//# sourceMappingURL=chunk-KQZIPQLJ.mjs.map
-//# sourceMappingURL=chunk-KQZIPQLJ.mjs.map
+// src/game-preloader/MockPreloaderApi.ts
+var MockPreloaderApi = class {
+  async showLoadScreen() {
+    console.log("showLoadScreen");
+  }
+  async hideLoadScreen() {
+    console.log("hideLoadScreen");
+  }
+  async setLoaderText(text) {
+    console.log("setLoaderText", text);
+  }
+  async setLoaderProgress(progress) {
+    console.log("setLoaderProgress", progress);
+  }
+};
+
+// src/game-preloader/RpcPreloaderApi.ts
+var RpcPreloaderApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async showLoadScreen() {
+    await this.rpcClient.call("H5_SHOW_LOAD_SCREEN" /* H5_SHOW_LOAD_SCREEN */);
+  }
+  async hideLoadScreen() {
+    await this.rpcClient.call("H5_HIDE_LOAD_SCREEN" /* H5_HIDE_LOAD_SCREEN */);
+  }
+  async setLoaderText(text) {
+    await this.rpcClient.call("H5_SET_LOADER_TEXT" /* H5_SET_LOADER_TEXT */, { text });
+  }
+  async setLoaderProgress(progress) {
+    await this.rpcClient.call("H5_SET_LOADER_PROGRESS" /* H5_SET_LOADER_PROGRESS */, { progress });
+  }
+};
+
+// src/game-preloader/index.ts
+function initializePreloader(venusApi, host) {
+  venusApi.preloader = host.preloader;
+}
+
+export { HapticFeedbackStyle, HostCdnApi, HostProfileApi, HostTimeApi, MockAdsApi, MockAiApi, MockAnalyticsApi, MockAvatarApi, MockCdnApi, MockFeaturesApi, MockHapticsApi, MockIapApi, MockLifecycleApi, MockLoggingApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockPreloaderApi, MockProfileApi, MockSharedAssetsApi, MockSimulationApi, MockStorageApi, MockTimeApi, RpcAdsApi, RpcAiApi, RpcAnalyticsApi, RpcAvatarApi, RpcClient, RpcFeaturesApi, RpcHapticsApi, RpcIapApi, RpcLifecycleApi, RpcLoggingApi, RpcNavigationApi, RpcNotificationsApi, RpcPopupsApi, RpcPreloaderApi, RpcSharedAssetsApi, RpcSimulationApi, RpcStorageApi, SDK_VERSION, VenusMessageId, VenusRoom, createMockStorageApi, init_VenusRoom, init_rooms, initializeAds, initializeAi, initializeAnalytics, initializeAvatar3d, initializeCdn, initializeFeaturesApi, initializeHaptics, initializeIap, initializeLifecycleApi, initializeLocalNotifications, initializeLoggingApi, initializePopups, initializePreloader, initializeProfile, initializeRoomsApi, initializeSimulation, initializeStackNavigation, initializeStorage, initializeTime, isPacificDaylightTime, rooms_exports, setupRoomNotifications };
+//# sourceMappingURL=chunk-YDXFZ2A2.mjs.map
+//# sourceMappingURL=chunk-YDXFZ2A2.mjs.map