mezon-js 2.12.13 → 2.12.15

package/api.gen.ts

@@ -5679,6 +5679,7 @@ export class MezonApi {
     token?: string,
     deviceId?: string,
     platform?: string,
+    voipToken?: string,
     options: any = {}
   ): Promise<ApiRegistFcmDeviceTokenResponse> {
     const urlPath = "/v2/devicetoken";
@@ -5686,6 +5687,7 @@ export class MezonApi {
     queryParams.set("token", token);
     queryParams.set("device_id", deviceId);
     queryParams.set("platform", platform);
+    queryParams.set("voip_token", voipToken);
 
     let bodyJson: string = "";
 

package/client.ts

@@ -1708,7 +1708,8 @@ export class Client {
     session: Session,
     tokenId: string,
     deviceId: string,
-    platform: string
+    platform: string,
+    voipToken?: string
   ): Promise<ApiRegistFcmDeviceTokenResponse> {
     if (
       this.autoRefreshSession &&
@@ -1719,7 +1720,7 @@ export class Client {
     }
 
     return this.apiClient
-      .registFCMDeviceToken(session.token, tokenId, deviceId, platform)
+      .registFCMDeviceToken(session.token, tokenId, deviceId, platform, voipToken)
       .then((response: any) => {
         return Promise.resolve(response);
       });

package/dist/api.gen.d.ts

@@ -1958,7 +1958,7 @@ export declare class MezonApi {
     /**  */
     deleteCategoryOrder(bearerToken: string, clanId: string, options?: any): Promise<any>;
     /** regist fcm device token */
-    registFCMDeviceToken(bearerToken: string, token?: string, deviceId?: string, platform?: string, options?: any): Promise<ApiRegistFcmDeviceTokenResponse>;
+    registFCMDeviceToken(bearerToken: string, token?: string, deviceId?: string, platform?: string, voipToken?: string, options?: any): Promise<ApiRegistFcmDeviceTokenResponse>;
     /** close direct message. */
     closeDirectMess(bearerToken: string, body: ApiDeleteChannelDescRequest, options?: any): Promise<any>;
     /** open direct message. */

package/dist/client.d.ts

@@ -435,7 +435,7 @@ export declare class Client {
     listRolePermissions(session: Session, roleId: string): Promise<ApiPermissionList>;
     /** List user roles */
     listRoleUsers(session: Session, roleId: string, limit?: number, cursor?: string): Promise<ApiRoleUserList>;
-    registFCMDeviceToken(session: Session, tokenId: string, deviceId: string, platform: string): Promise<ApiRegistFcmDeviceTokenResponse>;
+    registFCMDeviceToken(session: Session, tokenId: string, deviceId: string, platform: string, voipToken?: string): Promise<ApiRegistFcmDeviceTokenResponse>;
     /** Get a clan desc profile */
     getClanDescProfile(session: Session, clanId: string): Promise<ApiClanDescProfile>;
     getUserProfileOnClan(session: Session, clanId: string): Promise<ApiClanProfile>;

package/dist/mezon-js.cjs.js

@@ -2666,12 +2666,13 @@ var MezonApi = class {
     ]);
   }
   /** regist fcm device token */
-  registFCMDeviceToken(bearerToken, token, deviceId, platform, options = {}) {
+  registFCMDeviceToken(bearerToken, token, deviceId, platform, voipToken, options = {}) {
     const urlPath = "/v2/devicetoken";
     const queryParams = /* @__PURE__ */ new Map();
     queryParams.set("token", token);
     queryParams.set("device_id", deviceId);
     queryParams.set("platform", platform);
+    queryParams.set("voip_token", voipToken);
     let bodyJson = "";
     const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
     const fetchOptions = buildFetchOptions("POST", options, bodyJson);
@@ -6855,6 +6856,70 @@ var WebSocketAdapterText = class {
 };
 
 // socket.ts
+function CreateChannelMessageFromEvent(message) {
+  var content, reactions, mentions, attachments, references, referencedMessags;
+  try {
+    content = safeJSONParse(message.channel_message.content);
+  } catch (e2) {
+    console.log("content is invalid", e2);
+  }
+  try {
+    reactions = safeJSONParse(message.channel_message.reactions);
+  } catch (e2) {
+    console.log("reactions is invalid", e2);
+  }
+  try {
+    mentions = safeJSONParse(message.channel_message.mentions);
+  } catch (e2) {
+    console.log("mentions is invalid", e2);
+  }
+  try {
+    attachments = safeJSONParse(message.channel_message.attachments);
+  } catch (e2) {
+    console.log("attachments is invalid", e2);
+  }
+  try {
+    references = safeJSONParse(message.channel_message.references);
+  } catch (e2) {
+    console.log("references is invalid", e2);
+  }
+  try {
+    referencedMessags = safeJSONParse(message.channel_message.referenced_message);
+  } catch (e2) {
+    console.log("referenced messages is invalid", e2);
+  }
+  var e = {
+    id: message.id || message.channel_message.message_id,
+    avatar: message.channel_message.avatar,
+    channel_id: message.channel_message.channel_id,
+    mode: message.channel_message.mode,
+    channel_label: message.channel_message.channel_label,
+    clan_id: message.channel_message.clan_id,
+    code: message.channel_message.code,
+    create_time: message.channel_message.create_time,
+    message_id: message.channel_message.message_id,
+    sender_id: message.channel_message.sender_id,
+    update_time: message.channel_message.update_time,
+    clan_logo: message.channel_message.clan_logo,
+    category_name: message.channel_message.category_name,
+    username: message.channel_message.username,
+    clan_nick: message.channel_message.clan_nick,
+    clan_avatar: message.channel_message.clan_avatar,
+    display_name: message.channel_message.display_name,
+    content,
+    reactions,
+    mentions,
+    attachments,
+    referenced_message: referencedMessags,
+    references,
+    hide_editted: message.channel_message.hide_editted,
+    is_public: message.channel_message.is_public,
+    create_time_seconds: message.channel_message.create_time_seconds,
+    update_time_seconds: message.channel_message.update_time_seconds,
+    topic_id: message.channel_message.topic_id
+  };
+  return e;
+}
 var _DefaultSocket = class _DefaultSocket {
   constructor(host, port, useSSL = false, verbose = false, adapter = new WebSocketAdapterText(), sendTimeoutMs = _DefaultSocket.DefaultSendTimeoutMs) {
     this.host = host;
@@ -6956,68 +7021,11 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.stream_data) {
           this.onstreamdata(message.stream_data);
         } else if (message.channel_message) {
-          var content, reactions, mentions, attachments, references, referencedMessags;
-          try {
-            content = safeJSONParse(message.channel_message.content);
-          } catch (e2) {
-            console.log("content is invalid", e2);
-          }
-          try {
-            reactions = safeJSONParse(message.channel_message.reactions);
-          } catch (e2) {
-            console.log("reactions is invalid", e2);
-          }
-          try {
-            mentions = safeJSONParse(message.channel_message.mentions);
-          } catch (e2) {
-            console.log("mentions is invalid", e2);
-          }
-          try {
-            attachments = safeJSONParse(message.channel_message.attachments);
-          } catch (e2) {
-            console.log("attachments is invalid", e2);
-          }
-          try {
-            references = safeJSONParse(message.channel_message.references);
-          } catch (e2) {
-            console.log("references is invalid", e2);
-          }
-          try {
-            referencedMessags = safeJSONParse(message.channel_message.referenced_message);
-          } catch (e2) {
-            console.log("referenced messages is invalid", e2);
-          }
-          var e = {
-            id: message.id || message.channel_message.message_id,
-            avatar: message.channel_message.avatar,
-            channel_id: message.channel_message.channel_id,
-            mode: message.channel_message.mode,
-            channel_label: message.channel_message.channel_label,
-            clan_id: message.channel_message.clan_id,
-            code: message.channel_message.code,
-            create_time: message.channel_message.create_time,
-            message_id: message.channel_message.message_id,
-            sender_id: message.channel_message.sender_id,
-            update_time: message.channel_message.update_time,
-            clan_logo: message.channel_message.clan_logo,
-            category_name: message.channel_message.category_name,
-            username: message.channel_message.username,
-            clan_nick: message.channel_message.clan_nick,
-            clan_avatar: message.channel_message.clan_avatar,
-            display_name: message.channel_message.display_name,
-            content,
-            reactions,
-            mentions,
-            attachments,
-            referenced_message: referencedMessags,
-            references,
-            hide_editted: message.channel_message.hide_editted,
-            is_public: message.channel_message.is_public,
-            create_time_seconds: message.channel_message.create_time_seconds,
-            update_time_seconds: message.channel_message.update_time_seconds,
-            topic_id: message.channel_message.topic_id
-          };
-          this.onchannelmessage(e);
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onchannelmessage(channelMessage);
+        } else if (message.ephemeral_message_send) {
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onephemeralmessage(channelMessage);
         } else if (message.message_typing_event) {
           this.onmessagetyping(
             message.message_typing_event
@@ -7193,6 +7201,11 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(channelMessage);
     }
   }
+  onephemeralmessage(ephemeralMessage) {
+    if (this.verbose && window && window.console) {
+      console.log(ephemeralMessage);
+    }
+  }
   onchannelpresence(channelPresence) {
     if (this.verbose && window && window.console) {
       console.log(channelPresence);
@@ -7476,6 +7489,7 @@ var _DefaultSocket = class _DefaultSocket {
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
     const untypedMessage = message;
     return new Promise((resolve, reject) => {
+      var _a;
       if (!this.adapter.isOpen()) {
         reject("Socket connection has not been established yet.");
       } else {
@@ -7487,6 +7501,10 @@ var _DefaultSocket = class _DefaultSocket {
           untypedMessage.channel_message_update.content = JSON.stringify(
             untypedMessage.channel_message_update.content
           );
+        } else if (untypedMessage.ephemeral_message_send) {
+          untypedMessage.ephemeral_message_send.message.content = JSON.stringify(
+            (_a = untypedMessage.ephemeral_message_send.message) == null ? void 0 : _a.content
+          );
         }
         const cid = this.generatecid();
         this.cIds[cid] = { resolve, reject };
@@ -7612,6 +7630,31 @@ var _DefaultSocket = class _DefaultSocket {
   updateStatus(status) {
     return this.send({ status_update: { status } });
   }
+  writeEphemeralMessage(receiver_id, clan_id, channel_id, mode, is_public, content, mentions, attachments, references, anonymous_message, mention_everyone, avatar, code, topic_id) {
+    return __async(this, null, function* () {
+      const response = yield this.send({
+        ephemeral_message_send: {
+          receiver_id,
+          message: {
+            clan_id,
+            channel_id,
+            mode,
+            is_public,
+            content,
+            mentions,
+            attachments,
+            references,
+            anonymous_message,
+            mention_everyone,
+            avatar,
+            code,
+            topic_id
+          }
+        }
+      });
+      return response.channel_message_ack;
+    });
+  }
   writeChatMessage(clan_id, channel_id, mode, is_public, content, mentions, attachments, references, anonymous_message, mention_everyone, avatar, code, topic_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
@@ -8608,12 +8651,12 @@ var Client = class {
       });
     });
   }
-  registFCMDeviceToken(session, tokenId, deviceId, platform) {
+  registFCMDeviceToken(session, tokenId, deviceId, platform, voipToken) {
     return __async(this, null, function* () {
       if (this.autoRefreshSession && session.refresh_token && session.isexpired(Date.now() / 1e3)) {
         yield this.sessionRefresh(session);
       }
-      return this.apiClient.registFCMDeviceToken(session.token, tokenId, deviceId, platform).then((response) => {
+      return this.apiClient.registFCMDeviceToken(session.token, tokenId, deviceId, platform, voipToken).then((response) => {
         return Promise.resolve(response);
       });
     });

package/dist/mezon-js.esm.mjs

@@ -2632,12 +2632,13 @@ var MezonApi = class {
     ]);
   }
   /** regist fcm device token */
-  registFCMDeviceToken(bearerToken, token, deviceId, platform, options = {}) {
+  registFCMDeviceToken(bearerToken, token, deviceId, platform, voipToken, options = {}) {
     const urlPath = "/v2/devicetoken";
     const queryParams = /* @__PURE__ */ new Map();
     queryParams.set("token", token);
     queryParams.set("device_id", deviceId);
     queryParams.set("platform", platform);
+    queryParams.set("voip_token", voipToken);
     let bodyJson = "";
     const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
     const fetchOptions = buildFetchOptions("POST", options, bodyJson);
@@ -6821,6 +6822,70 @@ var WebSocketAdapterText = class {
 };
 
 // socket.ts
+function CreateChannelMessageFromEvent(message) {
+  var content, reactions, mentions, attachments, references, referencedMessags;
+  try {
+    content = safeJSONParse(message.channel_message.content);
+  } catch (e2) {
+    console.log("content is invalid", e2);
+  }
+  try {
+    reactions = safeJSONParse(message.channel_message.reactions);
+  } catch (e2) {
+    console.log("reactions is invalid", e2);
+  }
+  try {
+    mentions = safeJSONParse(message.channel_message.mentions);
+  } catch (e2) {
+    console.log("mentions is invalid", e2);
+  }
+  try {
+    attachments = safeJSONParse(message.channel_message.attachments);
+  } catch (e2) {
+    console.log("attachments is invalid", e2);
+  }
+  try {
+    references = safeJSONParse(message.channel_message.references);
+  } catch (e2) {
+    console.log("references is invalid", e2);
+  }
+  try {
+    referencedMessags = safeJSONParse(message.channel_message.referenced_message);
+  } catch (e2) {
+    console.log("referenced messages is invalid", e2);
+  }
+  var e = {
+    id: message.id || message.channel_message.message_id,
+    avatar: message.channel_message.avatar,
+    channel_id: message.channel_message.channel_id,
+    mode: message.channel_message.mode,
+    channel_label: message.channel_message.channel_label,
+    clan_id: message.channel_message.clan_id,
+    code: message.channel_message.code,
+    create_time: message.channel_message.create_time,
+    message_id: message.channel_message.message_id,
+    sender_id: message.channel_message.sender_id,
+    update_time: message.channel_message.update_time,
+    clan_logo: message.channel_message.clan_logo,
+    category_name: message.channel_message.category_name,
+    username: message.channel_message.username,
+    clan_nick: message.channel_message.clan_nick,
+    clan_avatar: message.channel_message.clan_avatar,
+    display_name: message.channel_message.display_name,
+    content,
+    reactions,
+    mentions,
+    attachments,
+    referenced_message: referencedMessags,
+    references,
+    hide_editted: message.channel_message.hide_editted,
+    is_public: message.channel_message.is_public,
+    create_time_seconds: message.channel_message.create_time_seconds,
+    update_time_seconds: message.channel_message.update_time_seconds,
+    topic_id: message.channel_message.topic_id
+  };
+  return e;
+}
 var _DefaultSocket = class _DefaultSocket {
   constructor(host, port, useSSL = false, verbose = false, adapter = new WebSocketAdapterText(), sendTimeoutMs = _DefaultSocket.DefaultSendTimeoutMs) {
     this.host = host;
@@ -6922,68 +6987,11 @@ var _DefaultSocket = class _DefaultSocket {
         } else if (message.stream_data) {
           this.onstreamdata(message.stream_data);
         } else if (message.channel_message) {
-          var content, reactions, mentions, attachments, references, referencedMessags;
-          try {
-            content = safeJSONParse(message.channel_message.content);
-          } catch (e2) {
-            console.log("content is invalid", e2);
-          }
-          try {
-            reactions = safeJSONParse(message.channel_message.reactions);
-          } catch (e2) {
-            console.log("reactions is invalid", e2);
-          }
-          try {
-            mentions = safeJSONParse(message.channel_message.mentions);
-          } catch (e2) {
-            console.log("mentions is invalid", e2);
-          }
-          try {
-            attachments = safeJSONParse(message.channel_message.attachments);
-          } catch (e2) {
-            console.log("attachments is invalid", e2);
-          }
-          try {
-            references = safeJSONParse(message.channel_message.references);
-          } catch (e2) {
-            console.log("references is invalid", e2);
-          }
-          try {
-            referencedMessags = safeJSONParse(message.channel_message.referenced_message);
-          } catch (e2) {
-            console.log("referenced messages is invalid", e2);
-          }
-          var e = {
-            id: message.id || message.channel_message.message_id,
-            avatar: message.channel_message.avatar,
-            channel_id: message.channel_message.channel_id,
-            mode: message.channel_message.mode,
-            channel_label: message.channel_message.channel_label,
-            clan_id: message.channel_message.clan_id,
-            code: message.channel_message.code,
-            create_time: message.channel_message.create_time,
-            message_id: message.channel_message.message_id,
-            sender_id: message.channel_message.sender_id,
-            update_time: message.channel_message.update_time,
-            clan_logo: message.channel_message.clan_logo,
-            category_name: message.channel_message.category_name,
-            username: message.channel_message.username,
-            clan_nick: message.channel_message.clan_nick,
-            clan_avatar: message.channel_message.clan_avatar,
-            display_name: message.channel_message.display_name,
-            content,
-            reactions,
-            mentions,
-            attachments,
-            referenced_message: referencedMessags,
-            references,
-            hide_editted: message.channel_message.hide_editted,
-            is_public: message.channel_message.is_public,
-            create_time_seconds: message.channel_message.create_time_seconds,
-            update_time_seconds: message.channel_message.update_time_seconds,
-            topic_id: message.channel_message.topic_id
-          };
-          this.onchannelmessage(e);
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onchannelmessage(channelMessage);
+        } else if (message.ephemeral_message_send) {
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onephemeralmessage(channelMessage);
         } else if (message.message_typing_event) {
           this.onmessagetyping(
             message.message_typing_event
@@ -7159,6 +7167,11 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(channelMessage);
     }
   }
+  onephemeralmessage(ephemeralMessage) {
+    if (this.verbose && window && window.console) {
+      console.log(ephemeralMessage);
+    }
+  }
   onchannelpresence(channelPresence) {
     if (this.verbose && window && window.console) {
       console.log(channelPresence);
@@ -7442,6 +7455,7 @@ var _DefaultSocket = class _DefaultSocket {
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
     const untypedMessage = message;
     return new Promise((resolve, reject) => {
+      var _a;
       if (!this.adapter.isOpen()) {
         reject("Socket connection has not been established yet.");
       } else {
@@ -7453,6 +7467,10 @@ var _DefaultSocket = class _DefaultSocket {
           untypedMessage.channel_message_update.content = JSON.stringify(
             untypedMessage.channel_message_update.content
           );
+        } else if (untypedMessage.ephemeral_message_send) {
+          untypedMessage.ephemeral_message_send.message.content = JSON.stringify(
+            (_a = untypedMessage.ephemeral_message_send.message) == null ? void 0 : _a.content
+          );
         }
         const cid = this.generatecid();
         this.cIds[cid] = { resolve, reject };
@@ -7578,6 +7596,31 @@ var _DefaultSocket = class _DefaultSocket {
   updateStatus(status) {
     return this.send({ status_update: { status } });
   }
+  writeEphemeralMessage(receiver_id, clan_id, channel_id, mode, is_public, content, mentions, attachments, references, anonymous_message, mention_everyone, avatar, code, topic_id) {
+    return __async(this, null, function* () {
+      const response = yield this.send({
+        ephemeral_message_send: {
+          receiver_id,
+          message: {
+            clan_id,
+            channel_id,
+            mode,
+            is_public,
+            content,
+            mentions,
+            attachments,
+            references,
+            anonymous_message,
+            mention_everyone,
+            avatar,
+            code,
+            topic_id
+          }
+        }
+      });
+      return response.channel_message_ack;
+    });
+  }
   writeChatMessage(clan_id, channel_id, mode, is_public, content, mentions, attachments, references, anonymous_message, mention_everyone, avatar, code, topic_id) {
     return __async(this, null, function* () {
       const response = yield this.send({
@@ -8574,12 +8617,12 @@ var Client = class {
       });
     });
   }
-  registFCMDeviceToken(session, tokenId, deviceId, platform) {
+  registFCMDeviceToken(session, tokenId, deviceId, platform, voipToken) {
     return __async(this, null, function* () {
       if (this.autoRefreshSession && session.refresh_token && session.isexpired(Date.now() / 1e3)) {
         yield this.sessionRefresh(session);
       }
-      return this.apiClient.registFCMDeviceToken(session.token, tokenId, deviceId, platform).then((response) => {
+      return this.apiClient.registFCMDeviceToken(session.token, tokenId, deviceId, platform, voipToken).then((response) => {
         return Promise.resolve(response);
       });
     });

package/dist/socket.d.ts

@@ -236,6 +236,9 @@ interface ChannelMessageSend {
         topic_id?: string;
     };
 }
+interface EphemeralMessageSend {
+    ephemeral_message_send: {};
+}
 /** Update a message previously sent to a realtime chat channel. */
 interface ChannelMessageUpdate {
     channel_message_update: {
@@ -779,6 +782,8 @@ export interface Socket {
     updateStatus(status?: string): Promise<void>;
     /** Send a chat message to a chat channel on the server. */
     writeChatMessage(clan_id: string, channel_id: string, mode: number, is_public: boolean, content?: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, references?: Array<ApiMessageRef>, anonymous_message?: boolean, mention_everyone?: boolean, avatar?: string, code?: number, topic_id?: string): Promise<ChannelMessageAck>;
+    /** Send a chat message to a chat channel on the server. */
+    writeEphemeralMessage(receiver_id: string, clan_id: string, channel_id: string, mode: number, is_public: boolean, content?: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, references?: Array<ApiMessageRef>, anonymous_message?: boolean, mention_everyone?: boolean, avatar?: string, code?: number, topic_id?: string): Promise<ChannelMessageAck>;
     /** Send message typing */
     writeMessageTyping(clan_id: string, channel_id: string, mode: number, is_public: boolean, sender_display_name: string): Promise<MessageTypingEvent>;
     /** Send message reaction */
@@ -821,6 +826,8 @@ export interface Socket {
     oncanvasevent: (canvasEvent: ChannelCanvas) => void;
     /** Receive channel message. */
     onchannelmessage: (channelMessage: ChannelMessage) => void;
+    /** Receive channel message. */
+    onephemeralmessage: (ephemeralMessage: ChannelMessage) => void;
     /** Receive typing event */
     onmessagetyping: (messageTypingEvent: MessageTypingEvent) => void;
     /** Receive reaction event */
@@ -915,6 +922,7 @@ export declare class DefaultSocket implements Socket {
     onmessagetyping(messagetyping: MessageTypingEvent): void;
     onmessagereaction(messagereaction: ApiMessageReaction): void;
     onchannelmessage(channelMessage: ChannelMessage): void;
+    onephemeralmessage(ephemeralMessage: ChannelMessage): void;
     onchannelpresence(channelPresence: ChannelPresenceEvent): void;
     onuserchanneladded(user: UserChannelAddedEvent): void;
     onuserclanadded(user: AddClanUserEvent): void;
@@ -971,7 +979,7 @@ export declare class DefaultSocket implements Socket {
     onuserstatusevent(user_status_event: UserStatusEvent): void;
     onJoinChannelAppEvent(join_channel_app_data: JoinChannelAppData): void;
     onUnpinMessageEvent(unpin_message_event: UnpinMessageEvent): void;
-    send(message: ChannelJoin | ChannelLeave | ChannelMessageSend | ChannelMessageUpdate | CustomStatusEvent | ChannelMessageRemove | MessageTypingEvent | LastSeenMessageEvent | Rpc | StatusFollow | StatusUnfollow | StatusUpdate | Ping | WebrtcSignalingFwd | IncomingCallPush | MessageButtonClicked | DropdownBoxSelected | ChannelAppEvent, sendTimeout?: number): Promise<any>;
+    send(message: ChannelJoin | ChannelLeave | ChannelMessageSend | ChannelMessageUpdate | CustomStatusEvent | ChannelMessageRemove | MessageTypingEvent | LastSeenMessageEvent | Rpc | StatusFollow | StatusUnfollow | StatusUpdate | Ping | WebrtcSignalingFwd | IncomingCallPush | MessageButtonClicked | DropdownBoxSelected | ChannelAppEvent | EphemeralMessageSend, sendTimeout?: number): Promise<any>;
     followUsers(userIds: string[]): Promise<Status>;
     joinClanChat(clan_id: string): Promise<ClanJoin>;
     follower(): Promise<void>;
@@ -983,6 +991,7 @@ export declare class DefaultSocket implements Socket {
     unfollowUsers(user_ids: string[]): Promise<void>;
     updateChatMessage(clan_id: string, channel_id: string, mode: number, is_public: boolean, message_id: string, content: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, hideEditted?: boolean, topic_id?: string, is_update_msg_topic?: boolean): Promise<ChannelMessageAck>;
     updateStatus(status?: string): Promise<void>;
+    writeEphemeralMessage(receiver_id: string, clan_id: string, channel_id: string, mode: number, is_public: boolean, content: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, references?: Array<ApiMessageRef>, anonymous_message?: boolean, mention_everyone?: Boolean, avatar?: string, code?: number, topic_id?: string): Promise<ChannelMessageAck>;
     writeChatMessage(clan_id: string, channel_id: string, mode: number, is_public: boolean, content: any, mentions?: Array<ApiMessageMention>, attachments?: Array<ApiMessageAttachment>, references?: Array<ApiMessageRef>, anonymous_message?: boolean, mention_everyone?: Boolean, avatar?: string, code?: number, topic_id?: string): Promise<ChannelMessageAck>;
     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, topic_id?: string, emoji_recent_id?: string): Promise<ApiMessageReaction>;
     writeMessageTyping(clan_id: string, channel_id: string, mode: number, is_public: boolean, sender_display_name: string): Promise<MessageTypingEvent>;

package/package.json

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

package/socket.ts

@@ -348,6 +348,12 @@ interface ChannelMessageSend {
   };
 }
 
+interface EphemeralMessageSend {
+  ephemeral_message_send: {
+
+  }
+}
+
 /** Update a message previously sent to a realtime chat channel. */
 interface ChannelMessageUpdate {
   channel_message_update: {
@@ -1062,6 +1068,72 @@ export interface ChannelCanvas {
   status?: number;
 }
 
+function CreateChannelMessageFromEvent(message: any) {
+  var content, reactions, mentions, attachments, references, referencedMessags;
+  try {
+    content = safeJSONParse(message.channel_message.content);
+  } catch (e) {
+    console.log("content is invalid", e);
+  }
+  try {
+    reactions = safeJSONParse(message.channel_message.reactions);
+  } catch (e) {
+    console.log("reactions is invalid", e);
+  }
+  try {
+    mentions = safeJSONParse(message.channel_message.mentions);
+  } catch (e) {
+    console.log("mentions is invalid", e);
+  }
+  try {
+    attachments = safeJSONParse(message.channel_message.attachments);
+  } catch (e) {
+    console.log("attachments is invalid", e);
+  }
+  try {
+    references = safeJSONParse(message.channel_message.references);
+  } catch (e) {
+    console.log("references is invalid", e);
+  }
+  try {
+    referencedMessags = safeJSONParse(message.channel_message.referenced_message);
+  } catch (e) {
+    console.log("referenced messages is invalid", e);
+  }
+  var e: ChannelMessage = {
+    id: message.id || message.channel_message.message_id,
+    avatar: message.channel_message.avatar,
+    channel_id: message.channel_message.channel_id,
+    mode: message.channel_message.mode,
+    channel_label: message.channel_message.channel_label,
+    clan_id: message.channel_message.clan_id,
+    code: message.channel_message.code,
+    create_time: message.channel_message.create_time,
+    message_id: message.channel_message.message_id,
+    sender_id: message.channel_message.sender_id,
+    update_time: message.channel_message.update_time,
+    clan_logo: message.channel_message.clan_logo,
+    category_name: message.channel_message.category_name,
+    username: message.channel_message.username,
+    clan_nick: message.channel_message.clan_nick,
+    clan_avatar: message.channel_message.clan_avatar,
+    display_name: message.channel_message.display_name,
+    content: content,
+    reactions: reactions,
+    mentions: mentions,
+    attachments: attachments,
+    referenced_message: referencedMessags,
+    references: references,
+    hide_editted: message.channel_message.hide_editted,
+    is_public: message.channel_message.is_public,
+    create_time_seconds: message.channel_message.create_time_seconds,
+    update_time_seconds: message.channel_message.update_time_seconds,
+    topic_id: message.channel_message.topic_id,
+  };
+
+  return e;
+}
+
 /** A socket connection to Mezon server. */
 export interface Socket {
   /** Connection is Open */
@@ -1163,6 +1235,24 @@ export interface Socket {
     topic_id?: string
   ): Promise<ChannelMessageAck>;
 
+  /** Send a chat message to a chat channel on the server. */
+  writeEphemeralMessage(
+    receiver_id: string,
+    clan_id: string,
+    channel_id: string,
+    mode: number,
+    is_public: boolean,
+    content?: any,
+    mentions?: Array<ApiMessageMention>,
+    attachments?: Array<ApiMessageAttachment>,
+    references?: Array<ApiMessageRef>,
+    anonymous_message?: boolean,
+    mention_everyone?: boolean,
+    avatar?: string,
+    code?: number,
+    topic_id?: string
+  ): Promise<ChannelMessageAck>;
+
   /** Send message typing */
   writeMessageTyping(
     clan_id: string,
@@ -1310,6 +1400,9 @@ export interface Socket {
   /** Receive channel message. */
   onchannelmessage: (channelMessage: ChannelMessage) => void;
 
+  /** Receive channel message. */
+  onephemeralmessage: (ephemeralMessage: ChannelMessage) => void;
+
   /** Receive typing event */
   onmessagetyping: (messageTypingEvent: MessageTypingEvent) => void;
 
@@ -1576,69 +1669,12 @@ export class DefaultSocket implements Socket {
           );
         } else if (message.stream_data) {
           this.onstreamdata(<StreamData>message.stream_data);
-        } else if (message.channel_message) {
-          var content, reactions, mentions, attachments, references, referencedMessags;
-          try {
-            content = safeJSONParse(message.channel_message.content);
-          } catch (e) {
-            console.log("content is invalid", e);
-          }
-          try {
-            reactions = safeJSONParse(message.channel_message.reactions);
-          } catch (e) {
-            console.log("reactions is invalid", e);
-          }
-          try {
-            mentions = safeJSONParse(message.channel_message.mentions);
-          } catch (e) {
-            console.log("mentions is invalid", e);
-          }
-          try {
-            attachments = safeJSONParse(message.channel_message.attachments);
-          } catch (e) {
-            console.log("attachments is invalid", e);
-          }
-          try {
-            references = safeJSONParse(message.channel_message.references);
-          } catch (e) {
-            console.log("references is invalid", e);
-          }
-          try {
-            referencedMessags = safeJSONParse(message.channel_message.referenced_message);
-          } catch (e) {
-            console.log("referenced messages is invalid", e);
-          }
-          var e: ChannelMessage = {
-            id: message.id || message.channel_message.message_id,
-            avatar: message.channel_message.avatar,
-            channel_id: message.channel_message.channel_id,
-            mode: message.channel_message.mode,
-            channel_label: message.channel_message.channel_label,
-            clan_id: message.channel_message.clan_id,
-            code: message.channel_message.code,
-            create_time: message.channel_message.create_time,
-            message_id: message.channel_message.message_id,
-            sender_id: message.channel_message.sender_id,
-            update_time: message.channel_message.update_time,
-            clan_logo: message.channel_message.clan_logo,
-            category_name: message.channel_message.category_name,
-            username: message.channel_message.username,
-            clan_nick: message.channel_message.clan_nick,
-            clan_avatar: message.channel_message.clan_avatar,
-            display_name: message.channel_message.display_name,
-            content: content,
-            reactions: reactions,
-            mentions: mentions,
-            attachments: attachments,
-            referenced_message: referencedMessags,
-            references: references,
-            hide_editted: message.channel_message.hide_editted,
-            is_public: message.channel_message.is_public,
-            create_time_seconds: message.channel_message.create_time_seconds,
-            update_time_seconds: message.channel_message.update_time_seconds,
-            topic_id: message.channel_message.topic_id,
-          };
-          this.onchannelmessage(e);
+        } else if (message.channel_message) {          
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onchannelmessage(channelMessage);
+        } else if (message.ephemeral_message_send) {
+          const channelMessage = CreateChannelMessageFromEvent(message);
+          this.onephemeralmessage(channelMessage);
         } else if (message.message_typing_event) {
           this.onmessagetyping(
             <MessageTypingEvent>message.message_typing_event
@@ -1828,6 +1864,12 @@ export class DefaultSocket implements Socket {
     }
   }
 
+  onephemeralmessage(ephemeralMessage: ChannelMessage) {
+    if (this.verbose && window && window.console) {
+      console.log(ephemeralMessage)
+    }
+  }
+
   onchannelpresence(channelPresence: ChannelPresenceEvent) {
     if (this.verbose && window && window.console) {
       console.log(channelPresence);
@@ -2183,7 +2225,8 @@ export class DefaultSocket implements Socket {
       | IncomingCallPush
       | MessageButtonClicked
       | DropdownBoxSelected
-      | ChannelAppEvent,
+      | ChannelAppEvent
+      | EphemeralMessageSend,
     sendTimeout = DefaultSocket.DefaultSendTimeoutMs
   ): Promise<any> {
     const untypedMessage = message as any;
@@ -2200,6 +2243,10 @@ export class DefaultSocket implements Socket {
           untypedMessage.channel_message_update.content = JSON.stringify(
             untypedMessage.channel_message_update.content
           );
+        } else if (untypedMessage.ephemeral_message_send) {
+          untypedMessage.ephemeral_message_send.message.content = JSON.stringify(
+            untypedMessage.ephemeral_message_send.message?.content
+          ); 
         }
 
         const cid = this.generatecid();
@@ -2365,6 +2412,45 @@ export class DefaultSocket implements Socket {
     return this.send({ status_update: { status: status } });
   }
 
+  async writeEphemeralMessage(
+    receiver_id: string,
+    clan_id: string,
+    channel_id: string,
+    mode: number,
+    is_public: boolean,
+    content: any,
+    mentions?: Array<ApiMessageMention>,
+    attachments?: Array<ApiMessageAttachment>,
+    references?: Array<ApiMessageRef>,
+    anonymous_message?: boolean,
+    mention_everyone?: Boolean,
+    avatar?: string,
+    code?: number,
+    topic_id?: string
+  ): Promise<ChannelMessageAck> {
+    const response = await this.send({
+      ephemeral_message_send: {
+        receiver_id: receiver_id,
+        message: {
+          clan_id: clan_id,
+          channel_id: channel_id,
+          mode: mode,
+          is_public: is_public,
+          content: content,
+          mentions: mentions,
+          attachments: attachments,
+          references: references,
+          anonymous_message: anonymous_message,
+          mention_everyone: mention_everyone,
+          avatar: avatar,
+          code: code,
+          topic_id: topic_id,
+        }
+      }
+    });
+    return response.channel_message_ack;
+  }
+
   async writeChatMessage(
     clan_id: string,
     channel_id: string,
@@ -2666,3 +2752,4 @@ export class DefaultSocket implements Socket {
     setTimeout(() => this.pingPong(), this._heartbeatTimeoutMs);
   }
 }
+