mezon-js 2.9.57 → 2.9.60

package/client.ts

@@ -1399,27 +1399,27 @@ export class Client {
           try {
             content = JSON.parse(m.content);
           } catch (e) {
-            //console.log("error parse content", e);
+            console.log("error parse content", e);
           }
           try {
             reactions = JSON.parse(m.reactions || "[]");
           } catch (e) {
-            //console.log("error parse reactions", e);
+            console.log("error parse reactions", e);
           }
           try {
             mentions = JSON.parse(m.mentions || "[]");
           } catch (e) {
-            //console.log("error parse mentions", e);
+            console.log("error parse mentions", e);
           }
           try {
             attachments = JSON.parse(m.attachments || "[]");
           } catch (e) {
-            //console.log("error parse attachments", e);
+            console.log("error parse attachments", e);
           }
           try {
             references = JSON.parse(m.references || "[]");
           } catch (e) {
-            //console.log("error parse references", e);
+            console.log("error parse references", e);
           }
           result.messages!.push({
             channel_id: m.channel_id,

package/dist/mezon-js.cjs.js

@@ -6293,22 +6293,27 @@ var _DefaultSocket = class _DefaultSocket {
           try {
             content = JSON.parse(message.channel_message.content);
           } catch (e2) {
+            console.log("content is invalid", e2);
           }
           try {
             reactions = JSON.parse(message.channel_message.reactions);
           } catch (e2) {
+            console.log("reactions is invalid", e2);
           }
           try {
             mentions = JSON.parse(message.channel_message.mentions);
           } catch (e2) {
+            console.log("mentions is invalid", e2);
           }
           try {
             attachments = JSON.parse(message.channel_message.attachments);
           } catch (e2) {
+            console.log("attachments is invalid", e2);
           }
           try {
             references = JSON.parse(message.channel_message.references);
           } catch (e2) {
+            console.log("references is invalid", e2);
           }
           var e = {
             id: message.id || message.channel_message.message_id,
@@ -6373,10 +6378,12 @@ var _DefaultSocket = class _DefaultSocket {
           this.onstreamingchanneljoined(message.streaming_joined_event);
         } else if (message.streaming_leaved_event) {
           this.onstreamingchannelleaved(message.streaming_leaved_event);
-        } else if (message.set_permission_channel_event) {
-          this.onsetpermissionchannel(message.set_permission_channel_event);
-        } else if (message.event_user_permission_channel) {
-          this.onuserpermissionchannel(message.event_user_permission_channel);
+        } else if (message.permission_set_event) {
+          this.onpermissionset(message.permission_set_event);
+        } else if (message.permission_changed_event) {
+          this.onpermissionchanged(message.permission_changed_event);
+        } else if (message.token_sent_event) {
+          this.ontokensent(message.token_sent_event);
         } else {
           if (this.verbose && window && window.console) {
             console.log("Unrecognized message received: %o", message);
@@ -6634,14 +6641,19 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(streaming_leaved_event);
     }
   }
-  onsetpermissionchannel(set_permission_channel_event) {
+  onpermissionset(permission_set_event) {
     if (this.verbose && window && window.console) {
-      console.log(set_permission_channel_event);
+      console.log(permission_set_event);
     }
   }
-  onuserpermissionchannel(event_user_permission_channel) {
+  onpermissionchanged(permission_changed_event) {
     if (this.verbose && window && window.console) {
-      console.log(event_user_permission_channel);
+      console.log(permission_changed_event);
+    }
+  }
+  ontokensent(tokenSentEvent) {
+    if (this.verbose && window && window.console) {
+      console.log(tokenSentEvent);
     }
   }
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
@@ -6795,6 +6807,12 @@ var _DefaultSocket = class _DefaultSocket {
       return response.check_name_existed_event;
     });
   }
+  sendToken(receiver_id, amount) {
+    return __async(this, null, function* () {
+      const response = yield this.send({ token_sent_event: { receiver_id, amount } });
+      return response.token_sent_event;
+    });
+  }
   pingPong() {
     return __async(this, null, function* () {
       if (!this.adapter.isOpen()) {
@@ -7398,22 +7416,27 @@ var Client = class {
           try {
             content = JSON.parse(m.content);
           } catch (e) {
+            console.log("error parse content", e);
           }
           try {
             reactions = JSON.parse(m.reactions || "[]");
           } catch (e) {
+            console.log("error parse reactions", e);
           }
           try {
             mentions = JSON.parse(m.mentions || "[]");
           } catch (e) {
+            console.log("error parse mentions", e);
           }
           try {
             attachments = JSON.parse(m.attachments || "[]");
           } catch (e) {
+            console.log("error parse attachments", e);
           }
           try {
             references = JSON.parse(m.references || "[]");
           } catch (e) {
+            console.log("error parse references", e);
           }
           result.messages.push({
             channel_id: m.channel_id,

package/dist/mezon-js.esm.mjs

@@ -6264,22 +6264,27 @@ var _DefaultSocket = class _DefaultSocket {
           try {
             content = JSON.parse(message.channel_message.content);
           } catch (e2) {
+            console.log("content is invalid", e2);
           }
           try {
             reactions = JSON.parse(message.channel_message.reactions);
           } catch (e2) {
+            console.log("reactions is invalid", e2);
           }
           try {
             mentions = JSON.parse(message.channel_message.mentions);
           } catch (e2) {
+            console.log("mentions is invalid", e2);
           }
           try {
             attachments = JSON.parse(message.channel_message.attachments);
           } catch (e2) {
+            console.log("attachments is invalid", e2);
           }
           try {
             references = JSON.parse(message.channel_message.references);
           } catch (e2) {
+            console.log("references is invalid", e2);
           }
           var e = {
             id: message.id || message.channel_message.message_id,
@@ -6344,10 +6349,12 @@ var _DefaultSocket = class _DefaultSocket {
           this.onstreamingchanneljoined(message.streaming_joined_event);
         } else if (message.streaming_leaved_event) {
           this.onstreamingchannelleaved(message.streaming_leaved_event);
-        } else if (message.set_permission_channel_event) {
-          this.onsetpermissionchannel(message.set_permission_channel_event);
-        } else if (message.event_user_permission_channel) {
-          this.onuserpermissionchannel(message.event_user_permission_channel);
+        } else if (message.permission_set_event) {
+          this.onpermissionset(message.permission_set_event);
+        } else if (message.permission_changed_event) {
+          this.onpermissionchanged(message.permission_changed_event);
+        } else if (message.token_sent_event) {
+          this.ontokensent(message.token_sent_event);
         } else {
           if (this.verbose && window && window.console) {
             console.log("Unrecognized message received: %o", message);
@@ -6605,14 +6612,19 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(streaming_leaved_event);
     }
   }
-  onsetpermissionchannel(set_permission_channel_event) {
+  onpermissionset(permission_set_event) {
     if (this.verbose && window && window.console) {
-      console.log(set_permission_channel_event);
+      console.log(permission_set_event);
     }
   }
-  onuserpermissionchannel(event_user_permission_channel) {
+  onpermissionchanged(permission_changed_event) {
     if (this.verbose && window && window.console) {
-      console.log(event_user_permission_channel);
+      console.log(permission_changed_event);
+    }
+  }
+  ontokensent(tokenSentEvent) {
+    if (this.verbose && window && window.console) {
+      console.log(tokenSentEvent);
     }
   }
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
@@ -6766,6 +6778,12 @@ var _DefaultSocket = class _DefaultSocket {
       return response.check_name_existed_event;
     });
   }
+  sendToken(receiver_id, amount) {
+    return __async(this, null, function* () {
+      const response = yield this.send({ token_sent_event: { receiver_id, amount } });
+      return response.token_sent_event;
+    });
+  }
   pingPong() {
     return __async(this, null, function* () {
       if (!this.adapter.isOpen()) {
@@ -7369,22 +7387,27 @@ var Client = class {
           try {
             content = JSON.parse(m.content);
           } catch (e) {
+            console.log("error parse content", e);
           }
           try {
             reactions = JSON.parse(m.reactions || "[]");
           } catch (e) {
+            console.log("error parse reactions", e);
           }
           try {
             mentions = JSON.parse(m.mentions || "[]");
           } catch (e) {
+            console.log("error parse mentions", e);
           }
           try {
             attachments = JSON.parse(m.attachments || "[]");
           } catch (e) {
+            console.log("error parse attachments", e);
           }
           try {
             references = JSON.parse(m.references || "[]");
           } catch (e) {
+            console.log("error parse references", e);
           }
           result.messages.push({
             channel_id: m.channel_id,

package/dist/socket.d.ts

@@ -556,7 +556,7 @@ export interface StreamingEndedEvent {
     /** channel id */
     channel_id: string;
 }
-export interface SetPermissionChannelEvent {
+export interface PermissionSet {
     /** Role ID */
     role_id: string;
     /** User ID */
@@ -568,10 +568,16 @@ export interface SetPermissionChannelEvent {
     /**  */
     caller: string;
 }
-export interface EventUserPermissionChannel {
+export interface PermissionChangedEvent {
     user_id: string;
     channel_id: string;
 }
+export interface TokenSentEvent {
+    sender_id: string;
+    sender_name: string;
+    receiver_id: string;
+    amount: number;
+}
 /** A socket connection to Mezon server. */
 export interface Socket {
     /** Connection is Open */
@@ -614,6 +620,8 @@ export interface Socket {
     writeVoiceJoined(id: string, clanId: string, clanName: string, voiceChannelId: string, voiceChannelLabel: string, participant: string, lastScreenshot: string): Promise<VoiceJoinedEvent>;
     /** send voice leaved */
     writeVoiceLeaved(id: string, clanId: string, voiceChannelId: string, voiceUserId: string): Promise<VoiceLeavedEvent>;
+    /** send token */
+    sendToken(receiver_id: string, amount: number): Promise<TokenSentEvent>;
     /** Handle disconnect events received from the socket. */
     ondisconnect: (evt: Event) => void;
     /** Handle error events received from the socket. */
@@ -680,8 +688,8 @@ export interface Socket {
     onstreamingchannelended: (streaming_ended_event: StreamingEndedEvent) => void;
     onstreamingchanneljoined: (streaming_joined_event: StreamingJoinedEvent) => void;
     onstreamingchannelleaved: (streaming_leaved_event: StreamingLeavedEvent) => void;
-    onsetpermissionchannel: (set_permission_channel_event: SetPermissionChannelEvent) => void;
-    onuserpermissionchannel: (event_user_permission_channel: EventUserPermissionChannel) => void;
+    onpermissionset: (permission_set_event: PermissionSet) => void;
+    onpermissionchanged: (permission_changed_event: PermissionChangedEvent) => void;
 }
 /** Reports an error received from a socket message. */
 export interface SocketError {
@@ -752,8 +760,9 @@ export declare class DefaultSocket implements Socket {
     onstreamingchannelended(streaming_ended_event: StreamingEndedEvent): void;
     onstreamingchanneljoined(streaming_joined_event: StreamingJoinedEvent): void;
     onstreamingchannelleaved(streaming_leaved_event: StreamingLeavedEvent): void;
-    onsetpermissionchannel(set_permission_channel_event: SetPermissionChannelEvent): void;
-    onuserpermissionchannel(event_user_permission_channel: EventUserPermissionChannel): void;
+    onpermissionset(permission_set_event: PermissionSet): void;
+    onpermissionchanged(permission_changed_event: PermissionChangedEvent): void;
+    ontokensent(tokenSentEvent: TokenSentEvent): void;
     send(message: ChannelJoin | ChannelLeave | ChannelMessageSend | ChannelMessageUpdate | CustomStatusEvent | ChannelMessageRemove | MessageTypingEvent | LastSeenMessageEvent | Rpc | StatusFollow | StatusUnfollow | StatusUpdate | Ping, sendTimeout?: number): Promise<any>;
     followUsers(userIds: string[]): Promise<Status>;
     joinClanChat(clan_id: string): Promise<ClanJoin>;
@@ -773,6 +782,7 @@ 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>;
+    sendToken(receiver_id: string, amount: number): Promise<TokenSentEvent>;
     private pingPong;
 }
 export {};

package/package.json

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

package/socket.ts

@@ -781,7 +781,7 @@ export interface StreamingEndedEvent {
   channel_id: string;
 }
 
-export interface SetPermissionChannelEvent {
+export interface PermissionSet {
   /** Role ID */
   role_id: string;
   /** User ID */
@@ -794,11 +794,22 @@ export interface SetPermissionChannelEvent {
   caller: string;
 }
 
-export interface EventUserPermissionChannel{
+export interface PermissionChangedEvent{
   user_id: string;
   channel_id: string;
 }
 
+export interface TokenSentEvent {
+  // sender id
+  sender_id: string;
+  // sender name
+  sender_name: string;
+  // receiver
+  receiver_id: string;
+  // amount of token
+  amount: number;
+}
+
 /** A socket connection to Mezon server. */
 export interface Socket {
   /** Connection is Open */
@@ -861,6 +872,9 @@ export interface Socket {
   /** send voice leaved */
   writeVoiceLeaved(id: string, clanId: string, voiceChannelId: string, voiceUserId: string) : Promise<VoiceLeavedEvent>;
 
+  /** send token */
+  sendToken(receiver_id: string, amount: number) : Promise<TokenSentEvent>;
+
   /** Handle disconnect events received from the socket. */
   ondisconnect: (evt: Event) => void;
 
@@ -987,9 +1001,9 @@ export interface Socket {
 
   onstreamingchannelleaved: (streaming_leaved_event: StreamingLeavedEvent) => void;
 
-  onsetpermissionchannel: (set_permission_channel_event: SetPermissionChannelEvent) => void;
+  onpermissionset: (permission_set_event: PermissionSet) => void;
 
-  onuserpermissionchannel: (event_user_permission_channel: EventUserPermissionChannel) => void;
+  onpermissionchanged: (permission_changed_event: PermissionChangedEvent) => void;
 }
 
 /** Reports an error received from a socket message. */
@@ -1104,27 +1118,27 @@ export class DefaultSocket implements Socket {
           try {           
             content = JSON.parse(message.channel_message.content);
           } catch(e) {
-            //console.log("content is invalid", e)
+            console.log("content is invalid", e)
           }    
           try {
             reactions = JSON.parse(message.channel_message.reactions);
           } catch(e) {
-            //console.log("reactions is invalid", e)
+            console.log("reactions is invalid", e)
           }    
           try {
             mentions = JSON.parse(message.channel_message.mentions);
           } catch(e) {
-            //console.log("mentions is invalid", e)
+            console.log("mentions is invalid", e)
           }  
           try {
             attachments = JSON.parse(message.channel_message.attachments);
           } catch(e) {
-            //console.log("attachments is invalid", e)
+            console.log("attachments is invalid", e)
           }
           try {
             references = JSON.parse(message.channel_message.references);
           } catch(e) {
-            //console.log("references is invalid", e);
+            console.log("references is invalid", e);
           }
           var e: ChannelMessage = {
             id: message.id || message.channel_message.message_id,
@@ -1189,10 +1203,12 @@ export class DefaultSocket implements Socket {
           this.onstreamingchanneljoined(<StreamingJoinedEvent>message.streaming_joined_event);
         } else if(message.streaming_leaved_event){
           this.onstreamingchannelleaved(<StreamingLeavedEvent>message.streaming_leaved_event);
-        } else if(message.set_permission_channel_event){
-          this.onsetpermissionchannel(<SetPermissionChannelEvent>message.set_permission_channel_event);
-        } else if(message.event_user_permission_channel){
-          this.onuserpermissionchannel(<EventUserPermissionChannel>message.event_user_permission_channel);
+        } else if(message.permission_set_event){
+          this.onpermissionset(<PermissionSet>message.permission_set_event);
+        } else if(message.permission_changed_event){
+          this.onpermissionchanged(<PermissionChangedEvent>message.permission_changed_event);
+        } else if (message.token_sent_event) {
+          this.ontokensent(<TokenSentEvent>message.token_sent_event);
         } else {
           if (this.verbose && window && window.console) {
             console.log("Unrecognized message received: %o", message);
@@ -1501,15 +1517,21 @@ export class DefaultSocket implements Socket {
     }
   }
   
-  onsetpermissionchannel(set_permission_channel_event: SetPermissionChannelEvent){
+  onpermissionset(permission_set_event: PermissionSet){
+    if (this.verbose && window && window.console) {
+      console.log(permission_set_event);
+    }
+  }
+
+  onpermissionchanged(permission_changed_event: PermissionChangedEvent){
     if (this.verbose && window && window.console) {
-      console.log(set_permission_channel_event);
+      console.log(permission_changed_event);
     }
   }
 
-  onuserpermissionchannel(event_user_permission_channel: EventUserPermissionChannel){
+  ontokensent(tokenSentEvent: TokenSentEvent) {
     if (this.verbose && window && window.console) {
-      console.log(event_user_permission_channel);
+      console.log(tokenSentEvent);
     }
   }
 
@@ -1625,42 +1647,47 @@ export class DefaultSocket implements Socket {
 
   async writeMessageReaction(id: string, clan_id: string, channel_id: string, mode: number, is_public: boolean, message_id: string, emoji_id: string, emoji: string, count: number, message_sender_id: string, action_delete: boolean): Promise<ApiMessageReaction> {
     const response = await this.send({message_reaction_event: {id: id, clan_id: clan_id, channel_id: channel_id, mode: mode, is_public: is_public, message_id: message_id, emoji_id: emoji_id, emoji: emoji, count: count, message_sender_id: message_sender_id, action: action_delete}});
-    return response.message_reaction_event
+    return response.message_reaction_event;
   }
 
   async writeMessageTyping(clan_id: string, channel_id: string, mode: number, is_public: boolean): Promise<MessageTypingEvent> {
     const response = await this.send({message_typing_event: {clan_id: clan_id, channel_id: channel_id, mode:mode, is_public: is_public}});
-    return response.message_typing_event
+    return response.message_typing_event;
   }
 
   async writeLastSeenMessage(clan_id: string, channel_id: string, mode: number, message_id: string, timestamp_seconds: number): Promise<LastSeenMessageEvent> {
     const response = await this.send({last_seen_message_event: {clan_id: clan_id, channel_id: channel_id, mode: mode, message_id: message_id, timestamp_seconds: timestamp_seconds}});
-    return response.last_seen_message_event
+    return response.last_seen_message_event;
   }
 
   async writeLastPinMessage(clan_id: string, channel_id: string, mode: number, is_public: boolean, message_id: string, timestamp_seconds: number, operation: number): Promise<LastPinMessageEvent> {
     const response = await this.send({last_pin_message_event: {clan_id: clan_id, channel_id: channel_id, mode: mode, is_public: is_public, message_id: message_id, timestamp_seconds: timestamp_seconds, operation: operation}});
-    return response.last_pin_message_event
+    return response.last_pin_message_event;
   }
 
   async writeVoiceJoined(id: string, clanId: string, clanName: string, voiceChannelId: string, voiceChannelLabel: string, participant: string, lastScreenshot: string): Promise<VoiceJoinedEvent> {
     const response = await this.send({voice_joined_event: {clan_id: clanId, clan_name: clanName, id: id, participant: participant, voice_channel_id: voiceChannelId, voice_channel_label: voiceChannelLabel, last_screenshot: lastScreenshot}});
-    return response.voice_joined_event
+    return response.voice_joined_event;
   }
 
   async writeVoiceLeaved(id: string, clanId: string, voiceChannelId: string, voiceUserId: string): Promise<VoiceLeavedEvent> {
     const response = await this.send({voice_leaved_event: {id: id, clan_id: clanId, voice_channel_id: voiceChannelId, voice_user_id: voiceUserId}});
-    return response.voice_leaved_event
+    return response.voice_leaved_event;
   }
 
   async writeCustomStatus(clan_id: string, status: string): Promise<CustomStatusEvent> {
     const response = await this.send({custom_status_event: {clan_id: clan_id, status: status}});
-    return response.custom_status_event
+    return response.custom_status_event;
   }
   
   async checkDuplicateName(name: string, condition_id: string, type: number): Promise<CheckNameExistedEvent> {
     const response = await this.send({check_name_existed_event: {name: name, condition_id: condition_id, type: type}});
-    return response.check_name_existed_event
+    return response.check_name_existed_event;
+  }
+
+  async sendToken(receiver_id: string, amount: number) : Promise<TokenSentEvent> {
+    const response = await this.send({token_sent_event: {receiver_id: receiver_id, amount: amount}});
+    return response.token_sent_event;
   }
 
   private async pingPong(): Promise<void> {