mezon-js 2.9.68 → 2.9.70

package/api.gen.ts

@@ -2444,43 +2444,66 @@ export interface RpcStatus {
   message?: string;
 }
 
+/**  */
 export interface ApiListOnboardingResponse {
   //
   list_onboarding?: Array<ApiOnboardingItem>;
 }
 
 /**  */
-export interface MezonUpdateOnboardingBody {
+export interface ApiAnswer {
   //
-  answers?: string;
+  answer?: string;
   //
-  channel_id?: string;
+  description?: string;
   //
-  clan_id?: string;
+  title?: string;
+}
+
+/**  */
+export interface ApiOnboardingContent {
+  //
+  answers?: Array<ApiAnswer>;
+  //
+  channel_id?: string;
   //
   content?: string;
   //
+  guide_type?: number;
+  //
   task_type?: number;
   //
   title?: string;
 }
 
 /**  */
-export interface ApiCreateOnboardingRequest {
+export interface MezonUpdateOnboardingBody {
+  //
+  answers?: Array<ApiAnswer>;
+  //
+  channel_id?: string;
   //
   clan_id?: string;
   //
   content?: string;
   //
-  guide_type?: number;
+  task_type?: number;
   //
   title?: string;
 }
 
+/**  */
+export interface ApiCreateOnboardingRequest {
+  //
+  clan_id?: string;
+  //
+  contents?: Array<ApiOnboardingContent>;
+}
+
 /**  */
 export interface ApiOnboardingItem {
   //
-  answers?: string;
+  answers?: Array<ApiAnswer>;
   //
   channel_id?: string;
   //

package/dist/api.gen.d.ts

@@ -1422,12 +1422,28 @@ export interface RpcStatus {
     details?: Array<ProtobufAny>;
     message?: string;
 }
+/**  */
 export interface ApiListOnboardingResponse {
     list_onboarding?: Array<ApiOnboardingItem>;
 }
 /**  */
+export interface ApiAnswer {
+    answer?: string;
+    description?: string;
+    title?: string;
+}
+/**  */
+export interface ApiOnboardingContent {
+    answers?: Array<ApiAnswer>;
+    channel_id?: string;
+    content?: string;
+    guide_type?: number;
+    task_type?: number;
+    title?: string;
+}
+/**  */
 export interface MezonUpdateOnboardingBody {
-    answers?: string;
+    answers?: Array<ApiAnswer>;
     channel_id?: string;
     clan_id?: string;
     content?: string;
@@ -1437,13 +1453,11 @@ export interface MezonUpdateOnboardingBody {
 /**  */
 export interface ApiCreateOnboardingRequest {
     clan_id?: string;
-    content?: string;
-    guide_type?: number;
-    title?: string;
+    contents?: Array<ApiOnboardingContent>;
 }
 /**  */
 export interface ApiOnboardingItem {
-    answers?: string;
+    answers?: Array<ApiAnswer>;
     channel_id?: string;
     clan_id?: string;
     content?: string;

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,69 @@ 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.handleMessageButtonClick(
+            message.message_button_clicked
+          );
+        } else if (message.call_request) {
+          console.log("message.call_request", message.call_request);
+          yield this.adapter.getRTCPeerConnection().setRemoteDescription(
+            new RTCSessionDescription({
+              type: "offer",
+              sdp: message.call_request.sdp
+            })
+          );
+          const answer = yield this.adapter.getRTCPeerConnection().createAnswer();
+          yield this.adapter.getRTCPeerConnection().setLocalDescription(answer);
+          yield this.sendCallAccept({
+            sdp: answer.sdp,
+            type: "answer"
+          });
+          this.onCallRequest(message.call_request);
+        } else if (message.call_accept) {
+          console.log("message.call_accept", message.call_accept);
+          yield this.adapter.getRTCPeerConnection().setRemoteDescription(
+            new RTCSessionDescription({
+              type: "answer",
+              sdp: message.call_accept.sdp
+            })
+          );
+          this.onCallAccept(message.call_accept);
+        } else if (message.ice_candidate_init) {
+          console.log("message.ice_candidate_init", message.ice_candidate_init);
+          const rtcIceCandidate = new RTCIceCandidate({
+            candidate: message.ice_candidate_init.candidate,
+            sdpMid: message.ice_candidate_init.sdpMid || "audio",
+            sdpMLineIndex: message.ice_candidate_init.sdpMLineIndex || 0,
+            usernameFragment: message.ice_candidate_init.usernameFragment || void 0
+          });
+          yield this.adapter.getRTCPeerConnection().addIceCandidate(rtcIceCandidate);
+          this.onIceCandidateInit(message.ice_candidate_init);
         } else {
           if (this.verbose && window && window.console) {
             console.log("Unrecognized message received: %o", message);
@@ -6786,7 +6874,7 @@ var _DefaultSocket = class _DefaultSocket {
           executor.resolve(message);
         }
       }
-    };
+    });
     return new Promise((resolve, reject) => {
       this.adapter.onOpen = (evt) => {
         if (this.verbose && window && window.console) {
@@ -7048,6 +7136,21 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(messageButtonClicked);
     }
   }
+  onCallRequest(callRequest) {
+    if (this.verbose && window && window.console) {
+      console.log(callRequest);
+    }
+  }
+  onCallAccept(callAccept) {
+    if (this.verbose && window && window.console) {
+      console.log(callAccept);
+    }
+  }
+  onIceCandidateInit(iceCandidateInit) {
+    if (this.verbose && window && window.console) {
+      console.log(iceCandidateInit);
+    }
+  }
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
     const untypedMessage = message;
     return new Promise((resolve, reject) => {
@@ -7055,9 +7158,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 };
@@ -7069,6 +7176,54 @@ var _DefaultSocket = class _DefaultSocket {
       }
     });
   }
+  getRTCPeerConnection() {
+    return this.adapter.getRTCPeerConnection();
+  }
+  startCall(localVideoRef, remoteVideoRef, grant_permissions) {
+    return __async(this, null, function* () {
+      this.adapter.getRTCPeerConnection().onicecandidate = (event) => {
+        if (event && event.candidate) {
+          this.sendICECandidateInit({ candidate: event == null ? void 0 : event.candidate });
+        }
+      };
+      this.adapter.getRTCPeerConnection().ontrack = (event) => {
+        if (remoteVideoRef) {
+          remoteVideoRef.srcObject = event.streams[0];
+        }
+      };
+      const stream = yield navigator.mediaDevices.getUserMedia(grant_permissions);
+      if (localVideoRef) {
+        localVideoRef.srcObject = stream;
+      }
+      stream.getTracks().forEach(
+        (track) => {
+          var _a;
+          return (_a = this.adapter.getRTCPeerConnection()) == null ? void 0 : _a.addTrack(track, stream);
+        }
+      );
+      const offer = yield this.adapter.getRTCPeerConnection().createOffer();
+      yield this.adapter.getRTCPeerConnection().setLocalDescription(offer);
+      yield this.sendCallRequest({
+        sdp: offer == null ? void 0 : offer.sdp,
+        type: "offer"
+      });
+    });
+  }
+  sendCallRequest(req) {
+    return __async(this, null, function* () {
+      return yield this.send({ call_request: req });
+    });
+  }
+  sendCallAccept(req) {
+    return __async(this, null, function* () {
+      return yield this.send({ call_accept: req });
+    });
+  }
+  sendICECandidateInit(req) {
+    return __async(this, null, function* () {
+      return yield this.send({ ice_candidate_init: req });
+    });
+  }
   followUsers(userIds) {
     return __async(this, null, function* () {
       const response = yield this.send({ status_follow: { user_ids: userIds } });
@@ -7087,49 +7242,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 +7294,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,55 +7315,133 @@ 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;
     });
   }