mezon-js 2.9.69 → 2.9.71

package/dist/mezon-js.esm.mjs

@@ -6510,7 +6510,9 @@ var WebSocketAdapterText = class {
       this._socket.onmessage = (evt) => {
         const message = JSON.parse(evt.data);
         if (message.party_data && message.party_data.data) {
-          message.party_data.data = new Uint8Array(decode2(message.party_data.data));
+          message.party_data.data = new Uint8Array(
+            decode2(message.party_data.data)
+          );
         }
         value(message);
       };
@@ -6534,12 +6536,21 @@ var WebSocketAdapterText = class {
         this.close();
       });
     }
-    const url = `${scheme}${host}:${port}/ws?lang=en&status=${encodeURIComponent(createStatus.toString())}&token=${encodeURIComponent(token)}&paltform=${encodeURIComponent(platform)}`;
+    const url = `${scheme}${host}:${port}/ws?lang=en&status=${encodeURIComponent(
+      createStatus.toString()
+    )}&token=${encodeURIComponent(token)}&paltform=${encodeURIComponent(
+      platform
+    )}`;
     this._socket = new WebSocket(url);
+    this._pcRef = new RTCPeerConnection({
+      iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
+    });
   }
   close() {
-    var _a;
-    (_a = this._socket) == null ? void 0 : _a.close();
+    var _a, _b;
+    (_a = this._pcRef) == null ? void 0 : _a.close();
+    this._pcRef = void 0;
+    (_b = this._socket) == null ? void 0 : _b.close();
     this._socket = void 0;
   }
   send(msg) {
@@ -6554,6 +6565,9 @@ var WebSocketAdapterText = class {
     }
     this._socket.send(JSON.stringify(msg));
   }
+  getRTCPeerConnection() {
+    return this._pcRef;
+  }
 };
 
 // socket.ts
@@ -6582,14 +6596,22 @@ var _DefaultSocket = class _DefaultSocket {
       return Promise.resolve(session);
     }
     const scheme = this.useSSL ? "wss://" : "ws://";
-    this.adapter.connect(scheme, this.host, this.port, createStatus, session.token, platform, signal);
+    this.adapter.connect(
+      scheme,
+      this.host,
+      this.port,
+      createStatus,
+      session.token,
+      platform,
+      signal
+    );
     this.adapter.onClose = (evt) => {
       this.ondisconnect(evt);
     };
     this.adapter.onError = (evt) => {
       this.onerror(evt);
     };
-    this.adapter.onMessage = (message) => {
+    this.adapter.onMessage = (message) => __async(this, null, function* () {
       if (this.verbose && window && window.console) {
         console.log("Response: %o", JSON.stringify(message));
       }
@@ -6632,9 +6654,13 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.last_seen_message_event) {
           this.onlastseenupdated(message.last_seen_message_event);
         } else if (message.status_presence_event) {
-          this.onstatuspresence(message.status_presence_event);
+          this.onstatuspresence(
+            message.status_presence_event
+          );
         } else if (message.stream_presence_event) {
-          this.onstreampresence(message.stream_presence_event);
+          this.onstreampresence(
+            message.stream_presence_event
+          );
         } else if (message.stream_data) {
           this.onstreamdata(message.stream_data);
         } else if (message.channel_message) {
@@ -6694,25 +6720,41 @@ var _DefaultSocket = class _DefaultSocket {
           };
           this.onchannelmessage(e);
         } else if (message.message_typing_event) {
-          this.onmessagetyping(message.message_typing_event);
+          this.onmessagetyping(
+            message.message_typing_event
+          );
         } else if (message.message_reaction_event) {
-          this.onmessagereaction(message.message_reaction_event);
+          this.onmessagereaction(
+            message.message_reaction_event
+          );
         } else if (message.channel_presence_event) {
-          this.onchannelpresence(message.channel_presence_event);
+          this.onchannelpresence(
+            message.channel_presence_event
+          );
         } else if (message.last_pin_message_event) {
-          this.onpinmessage(message.last_pin_message_event);
+          this.onpinmessage(
+            message.last_pin_message_event
+          );
         } else if (message.custom_status_event) {
           this.oncustomstatus(message.custom_status_event);
         } else if (message.user_channel_added_event) {
-          this.onuserchanneladded(message.user_channel_added_event);
+          this.onuserchanneladded(
+            message.user_channel_added_event
+          );
         } else if (message.add_clan_user_event) {
           this.onuserclanadded(message.add_clan_user_event);
         } else if (message.user_profile_updated_event) {
-          this.onuserprofileupdate(message.user_profile_updated_event);
+          this.onuserprofileupdate(
+            message.user_profile_updated_event
+          );
         } else if (message.user_channel_removed_event) {
-          this.onuserchannelremoved(message.user_channel_removed_event);
+          this.onuserchannelremoved(
+            message.user_channel_removed_event
+          );
         } else if (message.user_clan_removed_event) {
-          this.onuserclanremoved(message.user_clan_removed_event);
+          this.onuserclanremoved(
+            message.user_clan_removed_event
+          );
         } else if (message.clan_event_created) {
           this.oneventcreated(message.clan_event_created);
         } else if (message.give_coffee_event) {
@@ -6720,23 +6762,35 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.role_assign_event) {
           this.onroleassign(message.role_assign_event);
         } else if (message.streaming_started_event) {
-          this.onstreamingchannelstarted(message.streaming_started_event);
+          this.onstreamingchannelstarted(
+            message.streaming_started_event
+          );
         } else if (message.streaming_ended_event) {
-          this.onstreamingchannelended(message.streaming_ended_event);
+          this.onstreamingchannelended(
+            message.streaming_ended_event
+          );
         } else if (message.streaming_joined_event) {
-          this.onstreamingchanneljoined(message.streaming_joined_event);
+          this.onstreamingchanneljoined(
+            message.streaming_joined_event
+          );
         } else if (message.streaming_leaved_event) {
-          this.onstreamingchannelleaved(message.streaming_leaved_event);
+          this.onstreamingchannelleaved(
+            message.streaming_leaved_event
+          );
         } else if (message.permission_set_event) {
           this.onpermissionset(message.permission_set_event);
         } else if (message.permission_changed_event) {
-          this.onpermissionchanged(message.permission_changed_event);
+          this.onpermissionchanged(
+            message.permission_changed_event
+          );
         } else if (message.unmute_event) {
           this.onunmuteevent(message.unmute_event);
         } else if (message.token_sent_event) {
           this.ontokensent(message.token_sent_event);
         } else if (message.message_button_clicked) {
-          this.handleMessageButtonClick(message.message_button_clicked);
+          this.onmessagebuttonclicked(message.message_button_clicked);
+        } else if (message.webrtc_signaling_fwd) {
+          this.onwebrtcsignalingfwd(message.webrtc_signaling_fwd);
         } else {
           if (this.verbose && window && window.console) {
             console.log("Unrecognized message received: %o", message);
@@ -6757,7 +6811,7 @@ var _DefaultSocket = class _DefaultSocket {
           executor.resolve(message);
         }
       }
-    };
+    });
     return new Promise((resolve, reject) => {
       this.adapter.onOpen = (evt) => {
         if (this.verbose && window && window.console) {
@@ -7014,11 +7068,16 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(tokenSentEvent);
     }
   }
-  handleMessageButtonClick(messageButtonClicked) {
+  onmessagebuttonclicked(messageButtonClicked) {
     if (this.verbose && window && window.console) {
       console.log(messageButtonClicked);
     }
   }
+  onwebrtcsignalingfwd(event) {
+    if (this.verbose && window && window.console) {
+      console.log(event);
+    }
+  }
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
     const untypedMessage = message;
     return new Promise((resolve, reject) => {
@@ -7026,9 +7085,13 @@ var _DefaultSocket = class _DefaultSocket {
         reject("Socket connection has not been established yet.");
       } else {
         if (untypedMessage.channel_message_send) {
-          untypedMessage.channel_message_send.content = JSON.stringify(untypedMessage.channel_message_send.content);
+          untypedMessage.channel_message_send.content = JSON.stringify(
+            untypedMessage.channel_message_send.content
+          );
         } else if (untypedMessage.channel_message_update) {
-          untypedMessage.channel_message_update.content = JSON.stringify(untypedMessage.channel_message_update.content);
+          untypedMessage.channel_message_update.content = JSON.stringify(
+            untypedMessage.channel_message_update.content
+          );
         }
         const cid = this.generatecid();
         this.cIds[cid] = { resolve, reject };
@@ -7058,49 +7121,50 @@ var _DefaultSocket = class _DefaultSocket {
   }
   joinChat(clan_id, channel_id, channel_type, is_public) {
     return __async(this, null, function* () {
-      const response = yield this.send(
-        {
-          channel_join: {
-            clan_id,
-            channel_id,
-            channel_type,
-            is_public
-          }
+      const response = yield this.send({
+        channel_join: {
+          clan_id,
+          channel_id,
+          channel_type,
+          is_public
         }
-      );
+      });
       return response.channel;
     });
   }
   leaveChat(clan_id, channel_id, channel_type, is_public) {
-    return this.send({ channel_leave: { clan_id, channel_id, channel_type, is_public } });
+    return this.send({
+      channel_leave: {
+        clan_id,
+        channel_id,
+        channel_type,
+        is_public
+      }
+    });
   }
   removeChatMessage(clan_id, channel_id, mode, is_public, message_id) {
     return __async(this, null, function* () {
-      const response = yield this.send(
-        {
-          channel_message_remove: {
-            clan_id,
-            channel_id,
-            mode,
-            message_id,
-            is_public
-          }
+      const response = yield this.send({
+        channel_message_remove: {
+          clan_id,
+          channel_id,
+          mode,
+          message_id,
+          is_public
         }
-      );
+      });
       return response.channel_message_ack;
     });
   }
   rpc(id, payload, http_key) {
     return __async(this, null, function* () {
-      const response = yield this.send(
-        {
-          rpc: {
-            id,
-            payload,
-            http_key
-          }
+      const response = yield this.send({
+        rpc: {
+          id,
+          payload,
+          http_key
         }
-      );
+      });
       return response.rpc;
     });
   }
@@ -7109,7 +7173,19 @@ var _DefaultSocket = class _DefaultSocket {
   }
   updateChatMessage(clan_id, channel_id, mode, is_public, message_id, content, mentions, attachments, hideEditted) {
     return __async(this, null, function* () {
-      const response = yield this.send({ channel_message_update: { clan_id, channel_id, message_id, content, mentions, attachments, mode, is_public, hide_editted: hideEditted } });
+      const response = yield this.send({
+        channel_message_update: {
+          clan_id,
+          channel_id,
+          message_id,
+          content,
+          mentions,
+          attachments,
+          mode,
+          is_public,
+          hide_editted: hideEditted
+        }
+      });
       return response.channel_message_ack;
     });
   }
@@ -7118,58 +7194,152 @@ var _DefaultSocket = class _DefaultSocket {
   }
   writeChatMessage(clan_id, channel_id, mode, is_public, content, mentions, attachments, references, anonymous_message, mention_everyone, avatar) {
     return __async(this, null, function* () {
-      const response = yield this.send({ channel_message_send: { clan_id, channel_id, mode, is_public, content, mentions, attachments, references, anonymous_message, mention_everyone, avatar } });
+      const response = yield this.send({
+        channel_message_send: {
+          clan_id,
+          channel_id,
+          mode,
+          is_public,
+          content,
+          mentions,
+          attachments,
+          references,
+          anonymous_message,
+          mention_everyone,
+          avatar
+        }
+      });
       return response.channel_message_ack;
     });
   }
   writeMessageReaction(id, clan_id, channel_id, mode, is_public, message_id, emoji_id, emoji, count, message_sender_id, action_delete) {
     return __async(this, null, function* () {
-      const response = yield this.send({ message_reaction_event: { id, clan_id, channel_id, mode, is_public, message_id, emoji_id, emoji, count, message_sender_id, action: action_delete } });
+      const response = yield this.send({
+        message_reaction_event: {
+          id,
+          clan_id,
+          channel_id,
+          mode,
+          is_public,
+          message_id,
+          emoji_id,
+          emoji,
+          count,
+          message_sender_id,
+          action: action_delete
+        }
+      });
       return response.message_reaction_event;
     });
   }
   writeMessageTyping(clan_id, channel_id, mode, is_public) {
     return __async(this, null, function* () {
-      const response = yield this.send({ message_typing_event: { clan_id, channel_id, mode, is_public } });
+      const response = yield this.send({
+        message_typing_event: {
+          clan_id,
+          channel_id,
+          mode,
+          is_public
+        }
+      });
       return response.message_typing_event;
     });
   }
   writeLastSeenMessage(clan_id, channel_id, mode, message_id, timestamp_seconds) {
     return __async(this, null, function* () {
-      const response = yield this.send({ last_seen_message_event: { clan_id, channel_id, mode, message_id, timestamp_seconds } });
+      const response = yield this.send({
+        last_seen_message_event: {
+          clan_id,
+          channel_id,
+          mode,
+          message_id,
+          timestamp_seconds
+        }
+      });
       return response.last_seen_message_event;
     });
   }
   writeLastPinMessage(clan_id, channel_id, mode, is_public, message_id, timestamp_seconds, operation) {
     return __async(this, null, function* () {
-      const response = yield this.send({ last_pin_message_event: { clan_id, channel_id, mode, is_public, message_id, timestamp_seconds, operation } });
+      const response = yield this.send({
+        last_pin_message_event: {
+          clan_id,
+          channel_id,
+          mode,
+          is_public,
+          message_id,
+          timestamp_seconds,
+          operation
+        }
+      });
       return response.last_pin_message_event;
     });
   }
   writeVoiceJoined(id, clanId, clanName, voiceChannelId, voiceChannelLabel, participant, lastScreenshot) {
     return __async(this, null, function* () {
-      const response = yield this.send({ voice_joined_event: { clan_id: clanId, clan_name: clanName, id, participant, voice_channel_id: voiceChannelId, voice_channel_label: voiceChannelLabel, last_screenshot: lastScreenshot } });
+      const response = yield this.send({
+        voice_joined_event: {
+          clan_id: clanId,
+          clan_name: clanName,
+          id,
+          participant,
+          voice_channel_id: voiceChannelId,
+          voice_channel_label: voiceChannelLabel,
+          last_screenshot: lastScreenshot
+        }
+      });
       return response.voice_joined_event;
     });
   }
   writeVoiceLeaved(id, clanId, voiceChannelId, voiceUserId) {
     return __async(this, null, function* () {
-      const response = yield this.send({ voice_leaved_event: { id, clan_id: clanId, voice_channel_id: voiceChannelId, voice_user_id: voiceUserId } });
+      const response = yield this.send({
+        voice_leaved_event: {
+          id,
+          clan_id: clanId,
+          voice_channel_id: voiceChannelId,
+          voice_user_id: voiceUserId
+        }
+      });
       return response.voice_leaved_event;
     });
   }
   writeCustomStatus(clan_id, status) {
     return __async(this, null, function* () {
-      const response = yield this.send({ custom_status_event: { clan_id, status } });
+      const response = yield this.send({
+        custom_status_event: { clan_id, status }
+      });
       return response.custom_status_event;
     });
   }
   checkDuplicateName(name, condition_id, type) {
     return __async(this, null, function* () {
-      const response = yield this.send({ check_name_existed_event: { name, condition_id, type } });
+      const response = yield this.send({
+        check_name_existed_event: {
+          name,
+          condition_id,
+          type
+        }
+      });
       return response.check_name_existed_event;
     });
   }
+  forwardWebrtcSignaling(receiver_id, data_type, json_data) {
+    return __async(this, null, function* () {
+      const response = yield this.send({
+        webrtc_signaling_fwd: { receiver_id, data_type, json_data }
+      });
+      return response.webrtc_signaling_fwd;
+    });
+  }
+  handleMessageButtonClick(message_id, channel_id, button_id, sender_id, user_id) {
+    return __async(this, null, function* () {
+      const response = yield this.send({
+        message_button_clicked: { message_id, channel_id, button_id, sender_id, user_id }
+      });
+      return response.webrtc_signaling_fwd;
+    });
+  }
   pingPong() {
     return __async(this, null, function* () {
       if (!this.adapter.isOpen()) {

package/dist/socket.d.ts

@@ -584,6 +584,11 @@ export interface MessageButtonClicked {
     sender_id: string;
     user_id: string;
 }
+export interface WebrtcSignalingFwd {
+    receiverId: string;
+    dataType: number;
+    jsonData: string;
+}
 /** A socket connection to Mezon server. */
 export interface Socket {
     /** Connection is Open */
@@ -684,7 +689,10 @@ export interface Socket {
     setHeartbeatTimeoutMs(ms: number): void;
     getHeartbeatTimeoutMs(): number;
     checkDuplicateName(name: string, condition_id: string, type: number): Promise<CheckNameExistedEvent>;
-    handleMessageButtonClick: (message_button_clicked: MessageButtonClicked) => void;
+    handleMessageButtonClick: (message_id: string, channel_id: string, button_id: string, sender_id: string, user_id: string) => Promise<MessageButtonClicked>;
+    onmessagebuttonclicked: (event: MessageButtonClicked) => void;
+    forwardWebrtcSignaling: (receiverId: string, dataType: number, jsonData: string) => Promise<WebrtcSignalingFwd>;
+    onwebrtcsignalingfwd: (event: WebrtcSignalingFwd) => void;
     oneventcreated: (clan_event_created: ApiCreateEventRequest) => void;
     oncoffeegiven: (give_coffee_event: ApiGiveCoffeeEvent) => void;
     oneventemoji: (event_emoji: EventEmoji) => void;
@@ -771,8 +779,9 @@ export declare class DefaultSocket implements Socket {
     onpermissionchanged(permission_changed_event: PermissionChangedEvent): void;
     onunmuteevent(unmute_event: UnmuteEvent): void;
     ontokensent(tokenSentEvent: ApiTokenSentEvent): void;
-    handleMessageButtonClick(messageButtonClicked: MessageButtonClicked): void;
-    send(message: ChannelJoin | ChannelLeave | ChannelMessageSend | ChannelMessageUpdate | CustomStatusEvent | ChannelMessageRemove | MessageTypingEvent | LastSeenMessageEvent | Rpc | StatusFollow | StatusUnfollow | StatusUpdate | Ping, sendTimeout?: number): Promise<any>;
+    onmessagebuttonclicked(messageButtonClicked: MessageButtonClicked): void;
+    onwebrtcsignalingfwd(event: WebrtcSignalingFwd): void;
+    send(message: ChannelJoin | ChannelLeave | ChannelMessageSend | ChannelMessageUpdate | CustomStatusEvent | ChannelMessageRemove | MessageTypingEvent | LastSeenMessageEvent | Rpc | StatusFollow | StatusUnfollow | StatusUpdate | Ping | WebrtcSignalingFwd | MessageButtonClicked, sendTimeout?: number): Promise<any>;
     followUsers(userIds: string[]): Promise<Status>;
     joinClanChat(clan_id: string): Promise<ClanJoin>;
     joinChat(clan_id: string, channel_id: string, channel_type: number, is_public: boolean): Promise<Channel>;
@@ -791,6 +800,8 @@ export declare class DefaultSocket implements Socket {
     writeVoiceLeaved(id: string, clanId: string, voiceChannelId: string, voiceUserId: string): Promise<VoiceLeavedEvent>;
     writeCustomStatus(clan_id: string, status: string): Promise<CustomStatusEvent>;
     checkDuplicateName(name: string, condition_id: string, type: number): Promise<CheckNameExistedEvent>;
+    forwardWebrtcSignaling(receiver_id: string, data_type: number, json_data: string): Promise<WebrtcSignalingFwd>;
+    handleMessageButtonClick(message_id: string, channel_id: string, button_id: string, sender_id: string, user_id: string): Promise<MessageButtonClicked>;
     private pingPong;
 }
 export {};

package/dist/web_socket_adapter.d.ts

@@ -63,11 +63,18 @@ export interface SocketMessageHandler {
 export interface SocketOpenHandler {
     (this: WebSocket, evt: Event): void;
 }
+export interface RTCPeerOntrackHandler {
+    (this: RTCPeerConnection, ev: RTCTrackEvent): any | null;
+}
+export interface RTCPeerOnicecandidateHandler {
+    (this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent): any;
+}
 /**
  * A text-based socket adapter that accepts and transmits payloads over UTF-8.
  */
 export declare class WebSocketAdapterText implements WebSocketAdapter {
     private _socket?;
+    private _pcRef?;
     get onClose(): SocketCloseHandler | null;
     set onClose(value: SocketCloseHandler | null);
     get onError(): SocketErrorHandler | null;
@@ -80,4 +87,5 @@ export declare class WebSocketAdapterText implements WebSocketAdapter {
     connect(scheme: string, host: string, port: string, createStatus: boolean, token: string, platform: string, signal?: AbortSignal): void;
     close(): void;
     send(msg: any): void;
+    getRTCPeerConnection(): RTCPeerConnection;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mezon-js",
 
-  "version": "2.9.69",
+  "version": "2.9.71",
 
   "scripts": {
     "build": "npx tsc && npx rollup -c --bundleConfigAsCjs && node build.mjs"