@series-inc/venus-sdk 2.4.1 → 2.6.2

package/dist/core-R3FHW62G.mjs

@@ -0,0 +1,3 @@
+export { MOCK_DELAYS, createMockDelay, createProxiedMethod, createProxiedObject, isWebPlatform } from './chunk-W7IPHM67.mjs';
+//# sourceMappingURL=core-R3FHW62G.mjs.map
+//# sourceMappingURL=core-R3FHW62G.mjs.map

package/dist/{core-RDMPQV6U.mjs.map → core-R3FHW62G.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"core-RDMPQV6U.mjs"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"core-R3FHW62G.mjs"}

package/dist/index.cjs

@@ -119,6 +119,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;
@@ -140,7 +144,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");
@@ -189,6 +197,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) {
@@ -1553,7 +1563,7 @@ var MockNotificationsApi = class {
     __publicField(this, "venusApi");
     this.venusApi = venusApi;
   }
-  async cancelLocalNotification(notificationId) {
+  async cancelNotification(notificationId) {
     const venusApi = this.venusApi;
     if (isWebPlatform()) {
       console.log(
@@ -1594,16 +1604,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()}`;
@@ -1624,9 +1634,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);
@@ -1649,36 +1661,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
@@ -1826,17 +1878,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
     };
   }
 };
@@ -1847,7 +1904,8 @@ var MockProfileApi = class {
     return {
       id: "mock_profile_123",
       name: "Mock User",
-      username: "mockuser"
+      username: "mockuser",
+      isAnonymous: false
     };
   }
 };
@@ -1962,6 +2020,198 @@ var RpcClient = class {
   }
 };
 
+// src/rooms/VenusRoom.ts
+var 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/index.ts
+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;
+}
+
 // src/storage/MockStorageApi.ts
 function createMockStorageApi(storageType, appUrl) {
   const appIdentifier = appUrl ? generateAppIdentifier(appUrl) : null;
@@ -3292,7 +3542,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";
@@ -3363,6 +3613,47 @@ var MockSharedAssetsApi = class {
   }
 };
 
+// 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;
+}
+
 exports.HapticFeedbackStyle = HapticFeedbackStyle;
 exports.HostCdnApi = HostCdnApi;
 exports.HostProfileApi = HostProfileApi;
@@ -3380,6 +3671,7 @@ exports.MockLoggingApi = MockLoggingApi;
 exports.MockNavigationApi = MockNavigationApi;
 exports.MockNotificationsApi = MockNotificationsApi;
 exports.MockPopupsApi = MockPopupsApi;
+exports.MockPreloaderApi = MockPreloaderApi;
 exports.MockProfileApi = MockProfileApi;
 exports.MockSharedAssetsApi = MockSharedAssetsApi;
 exports.MockSimulationApi = MockSimulationApi;
@@ -3396,12 +3688,15 @@ exports.RpcIapApi = RpcIapApi;
 exports.RpcLifecycleApi = RpcLifecycleApi;
 exports.RpcLoggingApi = RpcLoggingApi;
 exports.RpcNavigationApi = RpcNavigationApi;
+exports.RpcNotificationsApi = RpcNotificationsApi;
 exports.RpcPopupsApi = RpcPopupsApi;
+exports.RpcPreloaderApi = RpcPreloaderApi;
 exports.RpcSharedAssetsApi = RpcSharedAssetsApi;
 exports.RpcSimulationApi = RpcSimulationApi;
 exports.RpcStorageApi = RpcStorageApi;
 exports.SDK_VERSION = SDK_VERSION;
 exports.VenusMessageId = VenusMessageId;
+exports.VenusRoom = VenusRoom;
 exports.createMockStorageApi = createMockStorageApi;
 exports.initializeAds = initializeAds;
 exports.initializeAi = initializeAi;
@@ -3415,11 +3710,14 @@ exports.initializeLifecycleApi = initializeLifecycleApi;
 exports.initializeLocalNotifications = initializeLocalNotifications;
 exports.initializeLoggingApi = initializeLoggingApi;
 exports.initializePopups = initializePopups;
+exports.initializePreloader = initializePreloader;
 exports.initializeProfile = initializeProfile;
+exports.initializeRoomsApi = initializeRoomsApi;
 exports.initializeSimulation = initializeSimulation;
 exports.initializeStackNavigation = initializeStackNavigation;
 exports.initializeStorage = initializeStorage;
 exports.initializeTime = initializeTime;
 exports.isPacificDaylightTime = isPacificDaylightTime;
+exports.setupRoomNotifications = setupRoomNotifications;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map