@softtynet/zca-js 2.2.9 → 2.3.1

package/dist/models/SeenMessage.js

@@ -1,15 +1,21 @@
 import { ThreadType } from "./Enum.js";
 export class UserSeenMessage {
+    type = ThreadType.User;
+    data;
+    threadId;
+    isSelf;
     constructor(data) {
-        this.type = ThreadType.User;
         this.data = data;
         this.threadId = data.idTo;
         this.isSelf = false;
     }
 }
 export class GroupSeenMessage {
+    type = ThreadType.Group;
+    data;
+    threadId;
+    isSelf;
     constructor(uid, data) {
-        this.type = ThreadType.Group;
         this.data = data;
         this.threadId = data.groupId;
         this.isSelf = data.seenUids.includes(uid);

package/dist/models/Typing.js

@@ -1,15 +1,21 @@
 import { ThreadType } from "./Enum.js";
 export class UserTyping {
+    type = ThreadType.User;
+    data;
+    threadId;
+    isSelf;
     constructor(data) {
-        this.type = ThreadType.User;
         this.data = data;
         this.threadId = data.uid;
         this.isSelf = false;
     }
 }
 export class GroupTyping {
+    type = ThreadType.Group;
+    data;
+    threadId;
+    isSelf;
     constructor(data) {
-        this.type = ThreadType.Group;
         this.data = data;
         this.threadId = data.gid;
         this.isSelf = false;

package/dist/models/Undo.js

@@ -1,4 +1,8 @@
 export class Undo {
+    data;
+    threadId;
+    isSelf;
+    isGroup;
     constructor(uid, data, isGroup) {
         this.data = data;
         this.threadId = isGroup || data.uidFrom == "0" ? data.idTo : data.uidFrom;

package/dist/realtime/handlers/control.handler.d.ts

@@ -0,0 +1,3 @@
+import type { ContextSession } from "../../context.js";
+import type { Listener } from "../listener.js";
+export declare function handleRealtimeControlPacket(listener: Listener, ctx: ContextSession, selfListen: boolean, version: number, cmd: number, subCmd: number, parsed: Record<string, unknown>, cipherKey?: string): Promise<boolean>;

package/dist/realtime/handlers/control.handler.js

@@ -0,0 +1,78 @@
+import { initializeCallEvent } from "../../models/CallEvent.js";
+import { initializeFriendEvent } from "../../models/FriendEvent.js";
+import { initializeGroupEvent } from "../../models/GroupEvent.js";
+import { initializeSyncEvent } from "../../models/SyncEvent.js";
+import { decodeEventData, getFriendEventType, getGroupEventType } from "../../utils.js";
+export async function handleRealtimeControlPacket(listener, ctx, selfListen, version, cmd, subCmd, parsed, cipherKey) {
+    if (version == 1 && cmd == 601 && subCmd == 0) {
+        const parsedData = (await decodeEventData(parsed, cipherKey)).data;
+        const { controls } = parsedData;
+        for (const control of controls) {
+            if (control.content.act_type == "file_done") {
+                const data = {
+                    fileUrl: control.content.data.url,
+                    fileId: control.content.fileId,
+                };
+                const uploadCallback = ctx.uploadCallbacks.get(String(control.content.fileId));
+                if (uploadCallback)
+                    uploadCallback(data);
+                ctx.uploadCallbacks.delete(String(control.content.fileId));
+                listener.emit("upload_attachment", data);
+            }
+            else if (control.content.act_type == "group") {
+                if (control.content.act == "join_reject")
+                    continue;
+                const groupEventData = typeof control.content.data == "string"
+                    ? JSON.parse(control.content.data)
+                    : control.content.data;
+                const groupEvent = initializeGroupEvent(ctx.uid, groupEventData, getGroupEventType(control.content.act), control.content.act);
+                if (groupEvent.isSelf && !selfListen)
+                    continue;
+                listener.emit("group_event", groupEvent);
+            }
+            else if (control.content.act_type == "fr") {
+                if (control.content.act == "req")
+                    continue;
+                const friendEventData = typeof control.content.data == "string"
+                    ? JSON.parse(control.content.data)
+                    : control.content.data;
+                if (typeof friendEventData == "object" &&
+                    "topic" in friendEventData &&
+                    typeof friendEventData.topic == "object" &&
+                    "params" in friendEventData.topic) {
+                    friendEventData.topic.params = JSON.parse(`${friendEventData.topic.params}`);
+                }
+                const friendEvent = initializeFriendEvent(ctx.uid, typeof friendEventData == "number" ? control.content.data : friendEventData, getFriendEventType(control.content.act));
+                if (friendEvent.isSelf && !selfListen)
+                    continue;
+                listener.emit("friend_event", friendEvent);
+            }
+            else if (control.content.act_type == "syncmsgmb" || control.content.act_type == "transfer_msg") {
+                const syncEventData = typeof control.content.data == "string"
+                    ? JSON.parse(control.content.data)
+                    : control.content.data;
+                const syncEvent = initializeSyncEvent(syncEventData, control.content.act, control.content.act_type);
+                listener.emit("sync_event", syncEvent);
+            }
+            else if (control.content.act_type == "voip") {
+                const callEventData = typeof control.content.data == "string"
+                    ? JSON.parse(control.content.data)
+                    : control.content.data;
+                const callEvent = initializeCallEvent(callEventData, control.content.act, control.content.act_type);
+                listener.emit("call_event", callEvent);
+            }
+            else if (control.content.act_type == "voice2text") {
+                const v2tData = typeof control.content.data == "string"
+                    ? JSON.parse(control.content.data)
+                    : control.content.data;
+                listener.emit("voice2text_event", {
+                    act: control.content.act,
+                    act_type: "voice2text",
+                    data: v2tData,
+                });
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/dist/realtime/handlers/message.handler.d.ts

@@ -0,0 +1,4 @@
+import type { ContextSession } from "../../context.js";
+import type { Listener } from "../listener.js";
+import type { OnMessageCallback } from "../types.js";
+export declare function handleRealtimeMessagePacket(listener: Listener, ctx: ContextSession, selfListen: boolean, onMessageCallback: OnMessageCallback, version: number, cmd: number, subCmd: number, parsed: Record<string, unknown>, cipherKey?: string): Promise<boolean>;

package/dist/realtime/handlers/message.handler.js

@@ -0,0 +1,87 @@
+import { GroupMessage, ThreadType, Undo, UserMessage } from "../../models/index.js";
+import { decodeEventData, hasOwn } from "../../utils.js";
+export async function handleRealtimeMessagePacket(listener, ctx, selfListen, onMessageCallback, version, cmd, subCmd, parsed, cipherKey) {
+    if (version == 1 && [501, 551].includes(cmd) && subCmd == 0) {
+        const parsedData = (await decodeEventData(parsed, cipherKey)).data;
+        const { msgs } = parsedData;
+        for (const msg of msgs) {
+            if (typeof msg.content == "object" && hasOwn(msg.content, "deleteMsg")) {
+                const undoObject = new Undo(ctx.uid, msg, false);
+                if (undoObject.isSelf && !selfListen)
+                    continue;
+                listener.emit("undo", undoObject);
+            }
+            else {
+                const messageObject = new UserMessage(ctx.uid, msg);
+                if (messageObject.isSelf && !selfListen)
+                    continue;
+                onMessageCallback(messageObject);
+                listener.emit("message", messageObject);
+            }
+        }
+        return true;
+    }
+    if (version == 1 && cmd == 521 && subCmd == 0) {
+        const parsedData = (await decodeEventData(parsed, cipherKey)).data;
+        const { groupMsgs } = parsedData;
+        for (const msg of groupMsgs) {
+            if (typeof msg.content == "object" && hasOwn(msg.content, "deleteMsg")) {
+                const undoObject = new Undo(ctx.uid, msg, true);
+                if (undoObject.isSelf && !selfListen)
+                    continue;
+                listener.emit("undo", undoObject);
+            }
+            else {
+                const messageObject = new GroupMessage(ctx.uid, msg);
+                if (messageObject.isSelf && !selfListen)
+                    continue;
+                onMessageCallback(messageObject);
+                listener.emit("message", messageObject);
+            }
+        }
+        return true;
+    }
+    if (cmd == 510 && (subCmd == 0 || subCmd == 1)) {
+        const decoded = await decodeEventData(parsed, cipherKey);
+        const parsedData = decoded?.data ?? decoded;
+        const msgs = (parsedData?.msgs ?? []);
+        const responseMsgs = [];
+        for (const msg of msgs) {
+            if (typeof msg.content == "object" && hasOwn(msg.content, "deleteMsg")) {
+                const undoObject = new Undo(ctx.uid, msg, false);
+                if (undoObject.isSelf && !selfListen)
+                    continue;
+                listener.emit("undo", undoObject);
+            }
+            else {
+                responseMsgs.push(new UserMessage(ctx.uid, msg));
+            }
+        }
+        if (responseMsgs.length > 0 || msgs.length === 0) {
+            listener.emit("old_messages", responseMsgs, ThreadType.User, parsedData?.more === 1);
+        }
+        return true;
+    }
+    if (cmd == 511 && (subCmd == 0 || subCmd == 1)) {
+        const decoded = await decodeEventData(parsed, cipherKey);
+        const parsedData = decoded?.data ?? decoded;
+        const groupMsgs = (parsedData?.groupMsgs ?? []);
+        const responseMsgs = [];
+        for (const msg of groupMsgs) {
+            if (typeof msg.content == "object" && hasOwn(msg.content, "deleteMsg")) {
+                const undoObject = new Undo(ctx.uid, msg, true);
+                if (undoObject.isSelf && !selfListen)
+                    continue;
+                listener.emit("undo", undoObject);
+            }
+            else {
+                responseMsgs.push(new GroupMessage(ctx.uid, msg));
+            }
+        }
+        if (responseMsgs.length > 0 || groupMsgs.length === 0) {
+            listener.emit("old_messages", responseMsgs, ThreadType.Group, parsedData?.more === 1);
+        }
+        return true;
+    }
+    return false;
+}

package/dist/realtime/handlers/reaction.handler.d.ts

@@ -0,0 +1,3 @@
+import type { ContextSession } from "../../context.js";
+import type { Listener } from "../listener.js";
+export declare function handleRealtimeReactionPacket(listener: Listener, ctx: ContextSession, selfListen: boolean, cmd: number, parsed: Record<string, unknown>, cipherKey?: string): Promise<boolean>;

package/dist/realtime/handlers/reaction.handler.js

@@ -0,0 +1,32 @@
+import { Reaction } from "../../models/index.js";
+import { decodeEventData } from "../../utils.js";
+export async function handleRealtimeReactionPacket(listener, ctx, selfListen, cmd, parsed, cipherKey) {
+    if (cmd == 612) {
+        const parsedData = (await decodeEventData(parsed, cipherKey)).data;
+        const { reacts, reactGroups } = parsedData;
+        for (const react of reacts) {
+            react.content = JSON.parse(react.content);
+            const reactionObject = new Reaction(ctx.uid, react, false);
+            if (reactionObject.isSelf && !selfListen)
+                continue;
+            listener.emit("reaction", reactionObject);
+        }
+        for (const reactGroup of reactGroups) {
+            reactGroup.content = JSON.parse(reactGroup.content);
+            const reactionObject = new Reaction(ctx.uid, reactGroup, true);
+            if (reactionObject.isSelf && !selfListen)
+                continue;
+            listener.emit("reaction", reactionObject);
+        }
+        return true;
+    }
+    if (cmd == 610 || cmd == 611) {
+        const parsedData = (await decodeEventData(parsed, cipherKey)).data;
+        const isGroup = cmd == 611;
+        const reacts = parsedData[isGroup ? "reactGroups" : "reacts"];
+        const reactionObjects = reacts.map((react) => new Reaction(ctx.uid, react, isGroup));
+        listener.emit("old_reactions", reactionObjects, isGroup);
+        return true;
+    }
+    return false;
+}

package/dist/realtime/handlers/status.handler.d.ts

@@ -0,0 +1,3 @@
+import type { ContextSession } from "../../context.js";
+import type { Listener } from "../listener.js";
+export declare function handleRealtimeStatusPacket(listener: Listener, ctx: ContextSession, selfListen: boolean, cmd: number, subCmd: number, parsed: Record<string, unknown>, cipherKey?: string): Promise<boolean>;

package/dist/realtime/handlers/status.handler.js

@@ -0,0 +1,66 @@
+import { ClearUnread } from "../../models/ClearUnread.js";
+import { GroupDeliveredMessage, UserDeliveredMessage } from "../../models/DeliveredMessage.js";
+import { GroupTyping, UserTyping } from "../../models/index.js";
+import { GroupSeenMessage, UserSeenMessage } from "../../models/SeenMessage.js";
+import { decodeEventData } from "../../utils.js";
+export async function handleRealtimeStatusPacket(listener, ctx, selfListen, cmd, subCmd, parsed, cipherKey) {
+    if ((cmd == 504 || cmd == 524) && subCmd == 0) {
+        const decoded = await decodeEventData(parsed, cipherKey);
+        const parsedData = decoded?.data ?? decoded;
+        const clearUnreads = (parsedData?.clearUnreads ?? []);
+        if (Array.isArray(clearUnreads) && clearUnreads.length > 0) {
+            const items = clearUnreads.map((item) => new ClearUnread(item));
+            listener.emit("unread_cleared", items);
+        }
+        return true;
+    }
+    if (cmd == 602 && subCmd == 0) {
+        const parsedData = (await decodeEventData(parsed, cipherKey)).data;
+        const { actions } = parsedData;
+        for (const action of actions) {
+            if (action.act_type == "typing") {
+                const data = JSON.parse(`{${action.data}}`);
+                if (action.act == "typing") {
+                    const typingObject = new UserTyping(data);
+                    listener.emit("typing", typingObject);
+                }
+                else if (action.act == "gtyping") {
+                    const typingObject = new GroupTyping(data);
+                    listener.emit("typing", typingObject);
+                }
+            }
+        }
+        return true;
+    }
+    if (cmd == 502 && subCmd == 0) {
+        const parsedData = (await decodeEventData(parsed, cipherKey)).data;
+        const { delivereds: deliveredMsgs, seens: seenMsgs } = parsedData;
+        if (Array.isArray(deliveredMsgs) && deliveredMsgs.length > 0) {
+            const deliveredObjects = deliveredMsgs.map((delivered) => new UserDeliveredMessage(delivered));
+            listener.emit("delivered_messages", deliveredObjects);
+        }
+        if (Array.isArray(seenMsgs) && seenMsgs.length > 0) {
+            const seenObjects = seenMsgs.map((seen) => new UserSeenMessage(seen));
+            listener.emit("seen_messages", seenObjects);
+        }
+        return true;
+    }
+    if (cmd == 522 && subCmd == 0) {
+        const parsedData = (await decodeEventData(parsed, cipherKey)).data;
+        const { delivereds: deliveredMsgs, groupSeens: groupSeenMsgs } = parsedData;
+        if (Array.isArray(deliveredMsgs) && deliveredMsgs.length > 0) {
+            let deliveredObjects = deliveredMsgs.map((delivered) => new GroupDeliveredMessage(ctx.uid, delivered));
+            if (!selfListen)
+                deliveredObjects = deliveredObjects.filter((delivered) => !delivered.isSelf);
+            listener.emit("delivered_messages", deliveredObjects);
+        }
+        if (Array.isArray(groupSeenMsgs) && groupSeenMsgs.length > 0) {
+            let seenObjects = groupSeenMsgs.map((seen) => new GroupSeenMessage(ctx.uid, seen));
+            if (!selfListen)
+                seenObjects = seenObjects.filter((seen) => !seen.isSelf);
+            listener.emit("seen_messages", seenObjects);
+        }
+        return true;
+    }
+    return false;
+}

package/dist/realtime/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./listener.js";

package/dist/realtime/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./listener.js";

package/dist/realtime/listener.d.ts

@@ -0,0 +1,69 @@
+import EventEmitter from "events";
+import { ThreadType } from "../models/index.js";
+import type { ContextSession } from "../context.js";
+import { type ListenerEvents, type OnClosedCallback, type OnErrorCallback, type OnMessageCallback, type WsPayload } from "./types.js";
+export declare class Listener extends EventEmitter<ListenerEvents> {
+    private ctx;
+    private urls;
+    private wsURL;
+    private cookie;
+    private userAgent;
+    private ws;
+    private retryCount;
+    private rotateCount;
+    private onConnectedCallback;
+    private onClosedCallback;
+    private onErrorCallback;
+    private onMessageCallback;
+    private cipherKey?;
+    private selfListen;
+    private pingInterval?;
+    private retryTimeout?;
+    private watchdogTimeout?;
+    private consecutive1006Count;
+    private id;
+    constructor(ctx: ContextSession, urls: string[]);
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onConnected(cb: () => unknown): void;
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onClosed(cb: OnClosedCallback): void;
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onError(cb: OnErrorCallback): void;
+    /**
+     * @deprecated Use `on` method instead
+     */
+    onMessage(cb: OnMessageCallback): void;
+    private isRetryable;
+    private canRetry;
+    private resetRetryCount;
+    private resetWatchdog;
+    private shouldRotate;
+    private rotateEndpoint;
+    start({ retryOnClose }?: {
+        retryOnClose?: boolean;
+    }): void;
+    stop(): void;
+    sendWs(payload: WsPayload, requireId?: boolean): void;
+    /**
+     * Request old messages from Zalo WebSocket queue (`cmd 510` for User, `cmd 511` for Group).
+     * When `lastMsgId` is `null` or omitted, defaults to `"10000000000000000"` to fetch the latest offline messages.
+     *
+     * @param threadType ThreadType.User or ThreadType.Group
+     * @param lastMsgId Optional cursor message ID (`actionId`) for pagination
+     */
+    requestOldMessages(threadType: ThreadType, lastMsgId?: string | null): void;
+    /**
+     * Request old reactions
+     *
+     * @param threadType ThreadType.User or ThreadType.Group
+     * @param lastMsgId Optional cursor message ID
+     */
+    requestOldReactions(threadType: ThreadType, lastMsgId?: string | null): void;
+    private reset;
+}