mezon-js 2.9.68 → 2.9.70

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,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);
@@ -6757,7 +6845,7 @@ var _DefaultSocket = class _DefaultSocket {
           executor.resolve(message);
         }
       }
-    };
+    });
     return new Promise((resolve, reject) => {
       this.adapter.onOpen = (evt) => {
         if (this.verbose && window && window.console) {
@@ -7019,6 +7107,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) => {
@@ -7026,9 +7129,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 };
@@ -7040,6 +7147,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 } });
@@ -7058,49 +7213,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 +7265,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,55 +7286,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;
     });
   }

package/dist/socket.d.ts

@@ -584,12 +584,27 @@ export interface MessageButtonClicked {
     sender_id: string;
     user_id: string;
 }
+export interface CallRequest {
+    type: string;
+    sdp: string;
+}
+export interface CallAccept {
+    type: string;
+    sdp: string;
+}
+export interface ICECandidateInit {
+    candidate: string;
+    sdpMid: string | undefined;
+    sdpMLineIndex: number | undefined;
+    usernameFragment: string | undefined;
+}
 /** A socket connection to Mezon server. */
 export interface Socket {
     /** Connection is Open */
     isOpen(): boolean;
     /** Connect to the server. */
     connect(session: Session, createStatus: boolean, platform: string, connectTimeoutMs?: number, signal?: AbortSignal): Promise<Session>;
+    getRTCPeerConnection(): RTCPeerConnection;
     /** Disconnect from the server. */
     disconnect(fireDisconnectEvent: boolean): void;
     /** Subscribe to one or more users for their status updates. */
@@ -685,6 +700,9 @@ export interface Socket {
     getHeartbeatTimeoutMs(): number;
     checkDuplicateName(name: string, condition_id: string, type: number): Promise<CheckNameExistedEvent>;
     handleMessageButtonClick: (message_button_clicked: MessageButtonClicked) => void;
+    onCallRequest: (call_request: CallRequest) => void;
+    onCallAccept: (call_accept: CallAccept) => void;
+    onIceCandidateInit: (ice_candidate_init: ICECandidateInit) => void;
     oneventcreated: (clan_event_created: ApiCreateEventRequest) => void;
     oncoffeegiven: (give_coffee_event: ApiGiveCoffeeEvent) => void;
     oneventemoji: (event_emoji: EventEmoji) => void;
@@ -697,6 +715,24 @@ export interface Socket {
     onpermissionchanged: (permission_changed_event: PermissionChangedEvent) => void;
     onunmuteevent: (unmute_event: UnmuteEvent) => void;
     ontokensent: (token: ApiTokenSentEvent) => void;
+    sendCallRequest(req: {
+        type: string;
+        sdp: string;
+    }): Promise<void>;
+    sendCallAccept(req: {
+        type: string;
+        sdp: string;
+    }): Promise<void>;
+    sendICECandidateInit(req: {
+        candidate: string;
+        sdpMid: string | undefined;
+        sdpMLineIndex: number | undefined;
+        usernameFragment: string | undefined;
+    }): Promise<void>;
+    startCall(localVideoRef: any, remoteVideoRef: any, grant_permissions: {
+        video: boolean;
+        audio: boolean;
+    }): Promise<void>;
 }
 /** Reports an error received from a socket message. */
 export interface SocketError {
@@ -772,7 +808,29 @@ export declare class DefaultSocket implements Socket {
     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>;
+    onCallRequest(callRequest: CallRequest): void;
+    onCallAccept(callAccept: CallAccept): void;
+    onIceCandidateInit(iceCandidateInit: ICECandidateInit): void;
+    send(message: ChannelJoin | ChannelLeave | ChannelMessageSend | ChannelMessageUpdate | CustomStatusEvent | ChannelMessageRemove | MessageTypingEvent | LastSeenMessageEvent | Rpc | StatusFollow | StatusUnfollow | StatusUpdate | Ping | CallRequest | CallAccept | ICECandidateInit, sendTimeout?: number): Promise<any>;
+    getRTCPeerConnection(): RTCPeerConnection;
+    startCall(localVideoRef: any, remoteVideoRef: any, grant_permissions: {
+        video: boolean;
+        audio: boolean;
+    }): Promise<void>;
+    sendCallRequest(req: {
+        type: string;
+        sdp?: string;
+    }): Promise<void>;
+    sendCallAccept(req: {
+        type: string;
+        sdp?: string;
+    }): Promise<void>;
+    sendICECandidateInit(req: {
+        candidate: string;
+        sdpMid?: string | undefined;
+        sdpMLineIndex?: number | undefined;
+        usernameFragment?: string | undefined;
+    }): Promise<void>;
     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>;

package/dist/web_socket_adapter.d.ts

@@ -37,6 +37,7 @@ export interface WebSocketAdapter {
     close(): void;
     connect(scheme: string, host: string, port: string, createStatus: boolean, token: string, platform: string, signal?: AbortSignal): void;
     send(message: any): void;
+    getRTCPeerConnection(): RTCPeerConnection;
 }
 /**
  * SocketCloseHandler defines a lambda that handles WebSocket close events.
@@ -63,11 +64,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 +88,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.68",
+  "version": "2.9.70",
 
   "scripts": {
     "build": "npx tsc && npx rollup -c --bundleConfigAsCjs && node build.mjs"