mezon-js 2.9.69 → 2.9.71

package/dist/mezon-js.cjs.js

@@ -6539,7 +6539,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);
       };
@@ -6563,12 +6565,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) {
@@ -6583,6 +6594,9 @@ var WebSocketAdapterText = class {
     }
     this._socket.send(JSON.stringify(msg));
   }
+  getRTCPeerConnection() {
+    return this._pcRef;
+  }
 };
 
 // socket.ts
@@ -6611,14 +6625,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));
       }
@@ -6661,9 +6683,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) {
@@ -6723,25 +6749,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) {
@@ -6749,23 +6791,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);
@@ -6786,7 +6840,7 @@ var _DefaultSocket = class _DefaultSocket {
           executor.resolve(message);
         }
       }
-    };
+    });
     return new Promise((resolve, reject) => {
       this.adapter.onOpen = (evt) => {
         if (this.verbose && window && window.console) {
@@ -7043,11 +7097,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) => {
@@ -7055,9 +7114,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 };
@@ -7087,49 +7150,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;
     });
   }
@@ -7138,7 +7202,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;
     });
   }
@@ -7147,58 +7223,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()) {