@softtynet/zca-js 2.3.3 → 2.3.5

package/dist/cjs/apis/call/requestVoiceCall.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const requestVoiceCallFactory = utils.apiFactory()((api, ctx, utils$1) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Xin cấp phát phiên gọi thoại / video và máy chủ relay RTP/RTCP (`/api/voicecall/requestcall`, command `11300`, signal `401`).
+     *
+     * @param calleeId User ID của người nhận cuộc gọi
+     * @param options Tuỳ chọn loại cuộc gọi (`callType`), `callId` và `codec`
+     * @throws {ZaloApiError}
+     */
+    return async function requestVoiceCall(calleeId, options = {}) {
+        if (!calleeId)
+            throw new ZaloApiError.ZaloApiError("Missing calleeId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const callType = options.callType ?? sendVoiceCall.CallType.Audio;
+        const callId = options.callId ?? Math.floor(Math.random() * 2_000_000_000);
+        const codec = options.codec ?? "[]";
+        const params = {
+            calleeId: String(calleeId),
+            callId,
+            codec,
+            typeRequest: callType,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils$1.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt requestVoiceCall params");
+        const url = utils$1.makeURL(`${voiceCallService}/api/voicecall/requestcall`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils$1.request(url, {
+            method: "GET",
+        });
+        const serverInfo = await utils.resolveResponse(ctx, response, (result) => {
+            const raw = result.data;
+            return typeof raw === "string" ? JSON.parse(raw) : raw;
+        });
+        return {
+            ...serverInfo,
+            callId,
+        };
+    };
+});
+
+exports.requestVoiceCallFactory = requestVoiceCallFactory;

package/dist/cjs/apis/call/ringRingGroupCall.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const ringRingGroupCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Báo hiệu thiết bị đang đổ chuông cho cuộc gọi nhóm (`/api/voicecall/group/ringring`, command `12439`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `calleeId`, `callType`, `partners` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function ringRingGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            calleeId: String(options.calleeId ?? ctx.uid),
+            callId,
+            callType: options.callType ?? sendVoiceCall.CallType.GroupAudio,
+            hostCall: String(options.hostCall),
+            data: dataStr,
+            partners: (options.partners ?? []).map(String),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt ringRingGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/ringring`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.ringRingGroupCallFactory = ringRingGroupCallFactory;

package/dist/cjs/apis/call/ringRingVoiceCall.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const ringRingVoiceCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Báo hiệu thiết bị của người nhận đang đổ chuông cho người gọi (`/api/voicecall/ringring`, command `11302`, signal `407`).
+     *
+     * @param callerId User ID của người gọi đến
+     * @param callId ID của cuộc gọi
+     * @param options Tuỳ chọn mã trạng thái (`status`, mặc định `0`)
+     * @throws {ZaloApiError}
+     */
+    return async function ringRingVoiceCall(callerId, callId, options = {}) {
+        if (!callerId)
+            throw new ZaloApiError.ZaloApiError("Missing callerId");
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            callerId: String(callerId),
+            callId,
+            status: options.status ?? 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt ringRingVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/ringring`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.ringRingVoiceCallFactory = ringRingVoiceCallFactory;

package/dist/cjs/apis/call/sendRequestGroupCall.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var sendVoiceCall = require('./sendVoiceCall.cjs');
+
+const sendRequestGroupCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi tín hiệu mời tham gia / đổ chuông cuộc gọi nhóm (`/api/voicecall/group/request`, command `12434`).
+     *
+     * @param groupId ID của nhóm
+     * @param options Thông tin `callId`, `session`, `partners`, `callType` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function sendRequestGroupCall(groupId, options) {
+        if (!groupId)
+            throw new ZaloApiError.ZaloApiError("Missing groupId");
+        if (!options?.callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.session)
+            throw new ZaloApiError.ZaloApiError("Missing session");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            calleeId: options.calleeId ?? "",
+            callId: options.callId,
+            callType: options.callType ?? sendVoiceCall.CallType.GroupAudio,
+            data: dataStr,
+            session: options.session,
+            partners: (options.partners ?? []).map(String),
+            groupId: String(groupId),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt sendRequestGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/request`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.sendRequestGroupCallFactory = sendRequestGroupCallFactory;

package/dist/cjs/apis/call/sendRequestVoiceCall.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const sendRequestVoiceCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi tín hiệu đổ chuông kèm thông tin kết nối RTP/RTCP & `extendData` (`/api/voicecall/request`, command `11301`, signal `416`).
+     *
+     * @param calleeId User ID của người nhận cuộc gọi
+     * @param options Thông tin `callId`, `session`, `rtpAddress`, `rtcpAddress`, `codec` và `extendData`
+     * @throws {ZaloApiError}
+     */
+    return async function sendRequestVoiceCall(calleeId, options) {
+        if (!calleeId)
+            throw new ZaloApiError.ZaloApiError("Missing calleeId");
+        if (!options?.callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.session)
+            throw new ZaloApiError.ZaloApiError("Missing session");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const extendDataStr = options.extendData === undefined
+            ? undefined
+            : typeof options.extendData === "string"
+                ? options.extendData
+                : JSON.stringify(options.extendData);
+        const params = {
+            calleeId: String(calleeId),
+            rtcpAddress: options.rtcpAddress ?? "",
+            rtpAddress: options.rtpAddress ?? "",
+            codec: options.codec ?? "[]",
+            session: options.session,
+            callId: options.callId,
+            imei: ctx.imei,
+        };
+        if (extendDataStr) {
+            params.extendData = extendDataStr;
+            params.subCommand = options.subCommand ?? 3;
+        }
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt sendRequestVoiceCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/request`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.sendRequestVoiceCallFactory = sendRequestVoiceCallFactory;

package/dist/cjs/apis/call/sendVoiceCall.cjs

@@ -1,12 +1,15 @@
 'use strict';
 
 var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var ZRTPPacketCodec = require('../../call-engine/ZRTPPacketCodec.cjs');
 var utils = require('../../utils.cjs');
 
 exports.CallType = void 0;
 (function (CallType) {
     CallType[CallType["Audio"] = 1] = "Audio";
     CallType[CallType["Video"] = 3] = "Video";
+    CallType[CallType["GroupAudio"] = 5] = "GroupAudio";
+    CallType[CallType["GroupVideo"] = 6] = "GroupVideo";
 })(exports.CallType || (exports.CallType = {}));
 function parseServerEndpoint(addr) {
     if (!addr)
@@ -35,7 +38,7 @@ const sendVoiceCallFactory = utils.apiFactory()((api, ctx, utils$1) => {
             throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
         const callType = options.callType ?? exports.CallType.Audio;
         const callId = options.callId ?? Math.floor(Math.random() * 2_000_000_000);
-        const codec = options.codec ?? "[]";
+        const codec = options.codec ?? ZRTPPacketCodec.DEFAULT_ZALO_AUDIO_CODEC;
         const normalizedCalleeId = String(calleeId);
         // Step 1: Allocate call session & RTP/RTCP relay endpoints (/api/voicecall/requestcall, command 11300)
         const step1Params = {
@@ -64,16 +67,15 @@ const sendVoiceCallFactory = utils.apiFactory()((api, ctx, utils$1) => {
         const rtp = parseServerEndpoint(resolvedRtpServer);
         const rtcp = parseServerEndpoint(resolvedRtcpServer);
         const sessId = serverInfo?.sessId ?? `${normalizedCalleeId}_${callId}_401`;
-        const resolvedCodec = serverInfo?.codec ?? codec;
+        const resolvedCodec = serverInfo?.codec && serverInfo.codec !== "[]" ? serverInfo.codec : codec;
         // Step 2: Send ringing signaling request (/api/voicecall/request, command 11301)
         const isVideo = callType === exports.CallType.Video;
         const extendData = JSON.stringify({
-            callType: isVideo ? 1 : 0,
-            video: {
-                codec: isVideo ? [{ name: "h264", payload: 97 }] : [],
-            },
-            newZrtc: 1,
-            platform: 5,
+            ...ZRTPPacketCodec.buildZrtcExtendData({
+                rtpAddress: rtp.host,
+                rtcpAddress: rtcp.host,
+                isVideo,
+            }),
             rtcpDiff: 0,
             rtcp: [{ ip: rtcp.ip, port: rtcp.port }],
             rtp: [{ ip: rtp.ip, port: rtp.port }],

package/dist/cjs/apis/call/shareScreenGroupCall.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const shareScreenGroupCallFactory = utils.apiFactory()((api, ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Bật/tắt chia sẻ màn hình trong cuộc gọi nhóm (`/api/voicecall/group/sharescreen`, command `12044`).
+     *
+     * @param callId ID của cuộc gọi nhóm
+     * @param options Thông tin `hostCall`, `userId`, `status`, `audioState`, `videoState` và `data`
+     * @throws {ZaloApiError}
+     */
+    return async function shareScreenGroupCall(callId, options) {
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!options?.hostCall)
+            throw new ZaloApiError.ZaloApiError("Missing hostCall");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? "{}"
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const params = {
+            userId: String(options.userId ?? ctx.uid),
+            callId,
+            hostCall: String(options.hostCall),
+            status: options.status ?? 1,
+            audiostate: options.audioState ?? 1,
+            videostate: options.videoState ?? 1,
+            data: dataStr,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt shareScreenGroupCall params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/group/sharescreen`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.shareScreenGroupCallFactory = shareScreenGroupCallFactory;

package/dist/cjs/apis/call/unholdVoiceCall.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const unholdVoiceCallFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Gửi yêu cầu tiếp tục cuộc gọi đang tạm giữ (`/api/voicecall/unholdreq`, command `11309`, signal `413`)
+     * hoặc phản hồi tiếp tục cuộc gọi (`/api/voicecall/unholdresp`, command `11310`, signal `414`).
+     *
+     * @param toId User ID của đối phương trong cuộc gọi
+     * @param options Đặt `isResponse = true` nếu là gói phản hồi (`unholdresp`)
+     * @throws {ZaloApiError}
+     */
+    return async function unholdVoiceCall(toId, options = {}) {
+        if (!toId)
+            throw new ZaloApiError.ZaloApiError("Missing toId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const params = {
+            toId: String(toId),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt unholdVoiceCall params");
+        const endpoint = options.isResponse ? "unholdresp" : "unholdreq";
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/${endpoint}`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.unholdVoiceCallFactory = unholdVoiceCallFactory;

package/dist/cjs/apis/call/updateCallMediaState.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const updateCallMediaStateFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const voiceCallService = api.zpwServiceMap.voice_call?.[0];
+    /**
+     * Đồng bộ trạng thái bật/tắt Camera và Microphone trong cuộc gọi 1-1 (`/api/voicecall/conf`, command `12006`).
+     * Khớp chính xác với `ZMessageSerializer::sendOnOffMicCam` (`0x100026cdc`):
+     * - Khi bật/tắt Camera (`UiOnOffCameraEvent`): `isOnCam = 1 | 0`, `isOnMic = -1`, `data = ""`
+     * - Khi bật/tắt Mic (`UiMuteEvent`): `isOnCam = -1`, `isOnMic = 1 | 0`, `data = ""`
+     *
+     * @param calleeId User ID của đối phương
+     * @param callId ID của cuộc gọi
+     * @param options Trạng thái `isOnCam`, `isOnMic` và `data` bổ sung
+     * @throws {ZaloApiError}
+     */
+    return async function updateCallMediaState(calleeId, callId, options) {
+        if (!calleeId)
+            throw new ZaloApiError.ZaloApiError("Missing calleeId");
+        if (!callId)
+            throw new ZaloApiError.ZaloApiError("Missing callId");
+        if (!voiceCallService)
+            throw new ZaloApiError.ZaloApiError("Missing voice_call service URL in zpwServiceMap");
+        const dataStr = options.data === undefined
+            ? ""
+            : typeof options.data === "string"
+                ? options.data
+                : JSON.stringify(options.data);
+        const isOnCamVal = options.isOnCam === undefined
+            ? -1
+            : typeof options.isOnCam === "boolean"
+                ? options.isOnCam
+                    ? 1
+                    : 0
+                : Number(options.isOnCam);
+        const isOnMicVal = options.isOnMic === undefined
+            ? -1
+            : typeof options.isOnMic === "boolean"
+                ? options.isOnMic
+                    ? 1
+                    : 0
+                : Number(options.isOnMic);
+        const params = {
+            calleeId: String(calleeId),
+            callId,
+            isOnCam: isOnCamVal,
+            isOnMic: isOnMicVal,
+            data: dataStr,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt updateCallMediaState params");
+        const url = utils.makeURL(`${voiceCallService}/api/voicecall/conf`, {
+            zpw_type: 24,
+            params: encryptedParams,
+        });
+        const response = await utils.request(url, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.updateCallMediaStateFactory = updateCallMediaStateFactory;

package/dist/cjs/apis/chat/getDirectMessageStatus.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+var wsCipher = require('../../crypto/ws-cipher.cjs');
+
+const getDirectMessageStatusFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.chat[0]}/api/message/getStatusMsg`);
+    /**
+     * Truy vấn trạng thái Đã nhận (`deliver`) và Đã xem (`seen`) tin nhắn trong các hội thoại cá nhân 1-1 (command 12016)
+     *
+     * @param data Danh sách UID hoặc đối tượng truy vấn `{ tId }`
+     * @throws {ZaloApiError}
+     */
+    return async function getDirectMessageStatus(data) {
+        if (!Array.isArray(data) || data.length === 0) {
+            throw new ZaloApiError.ZaloApiError("Missing data");
+        }
+        const formattedData = data.map((item) => (typeof item === "string" ? { tId: item } : item));
+        const params = {
+            param: JSON.stringify({
+                data: formattedData,
+            }),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            let rawData = result.data;
+            if (typeof rawData === "string" && rawData.length > 0) {
+                try {
+                    const parsed = JSON.parse(wsCipher.preParseJsonIds(rawData));
+                    rawData = "data" in parsed && parsed.data ? parsed.data : parsed;
+                }
+                catch {
+                    // Giữ nguyên nếu không phải chuỗi JSON lồng
+                }
+            }
+            if (rawData && typeof rawData === "object") {
+                const obj = rawData;
+                return {
+                    ...obj,
+                    statusInfos: Array.isArray(obj.statusInfos) ? obj.statusInfos : [],
+                };
+            }
+            return { statusInfos: [] };
+        });
+    };
+});
+
+exports.getDirectMessageStatusFactory = getDirectMessageStatusFactory;

package/dist/cjs/apis/chat/getSuggestedConversations.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getSuggestedConversationsFactory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/suggestconvers/list`);
+    /**
+     * Lấy danh sách các cuộc hội thoại được gợi ý (command 11233)
+     *
+     * @param language Ngôn ngữ hiển thị (mặc định theo `ctx.language` hoặc `"vi"`)
+     * @throws {ZaloApiError}
+     */
+    return async function getSuggestedConversations(language) {
+        const params = {
+            language: language ?? ctx.language ?? "vi",
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getSuggestedConversationsFactory = getSuggestedConversationsFactory;

package/dist/cjs/apis/chat/updatePinConversations.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const updatePinConversationsFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const v1ServiceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/pinconvers/update`);
+    const v2ServiceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/pinconvers/updatev2`);
+    /**
+     * Cập nhật danh sách hội thoại ghim qua `/api/pinconvers/update` (command 12121) hoặc `/api/pinconvers/updatev2` (command 12122)
+     *
+     * @param options Cấu hình danh sách hội thoại ghim
+     * @throws {ZaloApiError}
+     */
+    return async function updatePinConversations(options) {
+        if (!options || !Array.isArray(options.conversations)) {
+            throw new ZaloApiError.ZaloApiError("Missing conversations");
+        }
+        const useV2 = options.actionType !== undefined;
+        const targetURL = useV2 ? v2ServiceURL : v1ServiceURL;
+        const params = useV2
+            ? {
+                actionType: options.actionType,
+                conversations: options.conversations,
+                tab: options.tab,
+            }
+            : {
+                version: options.version ?? 0,
+                conversations: options.conversations,
+            };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(targetURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.updatePinConversationsFactory = updatePinConversationsFactory;

package/dist/cjs/apis/friend/getFriendProfilesV2.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var ZaloApiError = require('../../Errors/ZaloApiError.cjs');
+var utils = require('../../utils.cjs');
+
+const getFriendProfilesV2Factory = utils.apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getprofiles/v2`);
+    /**
+     * Lấy hàng loạt hồ sơ chi tiết của danh sách bạn bè kèm trạng thái online qua `/api/social/friend/getprofiles/v2` (command 11140)
+     *
+     * @param friendIds Mảng UID cần lấy hồ sơ (có thể kèm hậu tố `_version` hoặc truyền UID thuần)
+     * @param options Tùy chọn truy vấn
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendProfilesV2(friendIds, options = {}) {
+        const rawIds = Array.isArray(friendIds) ? friendIds : [friendIds];
+        if (rawIds.length === 0) {
+            throw new ZaloApiError.ZaloApiError("Missing friendIds");
+        }
+        const friendPversionMap = rawIds.map((id) => (id.includes("_") ? id : `${id}_0`));
+        const params = {
+            phonebook_version: options.phonebookVersion ?? 0,
+            friend_pversion_map: friendPversionMap,
+            avatar_size: options.avatarSize ?? 120,
+            language: options.language ?? ctx.language ?? "vi",
+            show_online_status: options.showOnlineStatus !== false ? 1 : 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams) {
+            throw new ZaloApiError.ZaloApiError("Failed to encrypt params");
+        }
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getFriendProfilesV2Factory = getFriendProfilesV2Factory;

package/dist/cjs/apis/friend/getFriendsActivePCWeb.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var utils = require('../../utils.cjs');
+
+const getFriendsActivePCWebFactory = utils.apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/active-pcweb`);
+    /**
+     * Lấy danh sách bạn bè đang hoạt động trên Zalo PC / Web qua `/api/social/friend/active-pcweb` (command 12072)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getFriendsActivePCWeb() {
+        const response = await utils.request(serviceURL, {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});
+
+exports.getFriendsActivePCWebFactory = getFriendsActivePCWebFactory;