@ohos-ports/zca-js 2.2.0-beta.1

package/dist/apis/getSentFriendRequest.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getSentFriendRequestFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.friend[0]}/api/friend/requested/list`);
+    /**
+     * Get friend requested
+     *
+     * @note Zalo might throw an error with code 112 if you have no friend requests.
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getSentFriendRequest() {
+        const params = {
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getSettings.d.ts

@@ -0,0 +1,3 @@
+import type { UserSetting } from "../models/index.js";
+export type GetSettingsResponse = UserSetting;
+export declare const getSettingsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<UserSetting>;

package/dist/apis/getSettings.js

@@ -0,0 +1,20 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getSettingsFactory = apiFactory()((_api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`https://wpa.chat.zalo.me/api/setting/me`);
+    /**
+     * Get my account settings
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getSettings() {
+        const params = {};
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getStickerCategoryDetail.d.ts

@@ -0,0 +1,3 @@
+import type { StickerDetail } from "../models/index.js";
+export type GetStickerCategoryDetailResponse = StickerDetail[];
+export declare const getStickerCategoryDetailFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (cateId: number) => Promise<GetStickerCategoryDetailResponse>;

package/dist/apis/getStickerCategoryDetail.js

@@ -0,0 +1,24 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getStickerCategoryDetailFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker[0]}/api/message/sticker/category/sticker_detail`);
+    /**
+     * Get sticker category detail
+     *
+     * @param cateId Sticker category ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickerCategoryDetail(cateId) {
+        const params = {
+            cid: cateId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/getStickers.d.ts

@@ -0,0 +1 @@
+export declare const getStickersFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (keyword: string) => Promise<number[]>;

package/dist/apis/getStickers.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getStickersFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker}/api/message/sticker`);
+    /**
+     * Get stickers by keyword
+     *
+     * @param keyword Keyword to search for
+     * @returns Sticker IDs
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickers(keyword) {
+        if (!keyword)
+            throw new ZaloApiError("Missing keyword");
+        const params = {
+            keyword: keyword,
+            gif: 1,
+            guggy: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt message");
+        const finalServiceUrl = new URL(serviceURL);
+        finalServiceUrl.pathname = finalServiceUrl.pathname + "/suggest/stickers";
+        const response = await utils.request(utils.makeURL(finalServiceUrl.toString(), {
+            params: encryptedParams,
+        }));
+        return utils.resolve(response, (result) => {
+            const suggestions = result.data;
+            const stickerIds = [];
+            // @TODO: Implement these
+            // suggestions.sugg_guggy, suggestions.sugg_gif
+            if (suggestions.sugg_sticker)
+                suggestions.sugg_sticker.forEach((sticker) => stickerIds.push(sticker.sticker_id));
+            return stickerIds;
+        });
+    };
+});

package/dist/apis/getStickersDetail.d.ts

@@ -0,0 +1,3 @@
+import type { StickerDetail } from "../models/index.js";
+export type StickerDetailResponse = StickerDetail[];
+export declare const getStickersDetailFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (stickerIds: number | number[]) => Promise<StickerDetailResponse>;

package/dist/apis/getStickersDetail.js

@@ -0,0 +1,40 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory, resolveResponse } from "../utils.js";
+export const getStickersDetailFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.sticker}/api/message/sticker/sticker_detail`);
+    /**
+     * Get stickers detail by sticker IDs
+     *
+     * @param stickerIds Sticker IDs to search for
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getStickersDetail(stickerIds) {
+        if (!stickerIds)
+            throw new ZaloApiError("Missing sticker id");
+        if (!Array.isArray(stickerIds))
+            stickerIds = [stickerIds];
+        if (stickerIds.length == 0)
+            throw new ZaloApiError("Missing sticker id");
+        const stickers = [];
+        const tasks = stickerIds.map((stickerId) => getStickerDetail(stickerId));
+        const tasksResult = await Promise.allSettled(tasks);
+        tasksResult.forEach((result) => {
+            if (result.status === "fulfilled")
+                stickers.push(result.value);
+        });
+        return stickers;
+    };
+    async function getStickerDetail(stickerId) {
+        const params = {
+            sid: stickerId,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt message");
+        const response = await utils.request(utils.makeURL(serviceURL, {
+            params: encryptedParams,
+        }));
+        return resolveResponse(ctx, response);
+    }
+});

package/dist/apis/getUnreadMark.d.ts

@@ -0,0 +1,14 @@
+export type UnreadMark = {
+    id: number;
+    cliMsgId: number;
+    fromUid: number;
+    ts: number;
+};
+export type GetUnreadMarkResponse = {
+    data: {
+        convsGroup: UnreadMark[];
+        convsUser: UnreadMark[];
+    };
+    status: number;
+};
+export declare const getUnreadMarkFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<GetUnreadMarkResponse>;

package/dist/apis/getUnreadMark.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const getUnreadMarkFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.conversation[0]}/api/conv/getUnreadMark`);
+    /**
+     * Get unread mark
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getUnreadMark() {
+        const params = {};
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            if (typeof data.data === "string") {
+                return {
+                    data: JSON.parse(data.data),
+                    status: data.status,
+                };
+            }
+            return data;
+        });
+    };
+});

package/dist/apis/getUserInfo.d.ts

@@ -0,0 +1,8 @@
+import { AvatarSize, type UnchangedProfileInfo, type User } from "../models/index.js";
+export type ProfileInfo = User;
+export type UserInfoResponse = {
+    unchanged_profiles: Record<string, Partial<UnchangedProfileInfo>>;
+    phonebook_version: number;
+    changed_profiles: Record<string, ProfileInfo>;
+};
+export declare const getUserInfoFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (userId: string | string[], avatarSize?: AvatarSize) => Promise<UserInfoResponse>;

package/dist/apis/getUserInfo.js

@@ -0,0 +1,44 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+import { AvatarSize } from "../models/index.js";
+export const getUserInfoFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/friend/getprofiles/v2`);
+    /**
+     * Get user info using user id
+     *
+     * @param userId User id(s)
+     * @param avatarSize Avatar size (default: AvatarSize.Small)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getUserInfo(userId, avatarSize = AvatarSize.Small) {
+        if (!userId)
+            throw new ZaloApiError("Missing user id");
+        if (!Array.isArray(userId))
+            userId = [userId];
+        userId = userId.map((id) => {
+            if (id.split("_").length > 1) {
+                return id;
+            }
+            return `${id}_0`;
+        });
+        const params = {
+            phonebook_version: ctx.extraVer.phonebook,
+            friend_pversion_map: userId,
+            avatar_size: avatarSize,
+            language: ctx.language,
+            show_online_status: 1,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/inviteUserToGroups.d.ts

@@ -0,0 +1,10 @@
+export type InviteUserToGroupsResponse = {
+    grid_message_map: {
+        [groupId: string]: {
+            error_code: number;
+            error_message: string;
+            data: string | null;
+        };
+    };
+};
+export declare const inviteUserToGroupsFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (userId: string, groupId: string | string[]) => Promise<InviteUserToGroupsResponse>;

package/dist/apis/inviteUserToGroups.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const inviteUserToGroupsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/invite/multi`);
+    /**
+     * Invite user to group
+     *
+     * @param groupId group ID(s)
+     * @param memberId member ID
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function inviteUserToGroups(userId, groupId) {
+        const params = {
+            grids: Array.isArray(groupId) ? groupId : [groupId],
+            member: userId,
+            memberType: -1,
+            srcInteraction: 2,
+            clientLang: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/joinGroupInviteBox.d.ts

@@ -0,0 +1,2 @@
+export type JoinGroupInviteBoxResponse = "";
+export declare const joinGroupInviteBoxFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string) => Promise<"">;

package/dist/apis/joinGroupInviteBox.js

@@ -0,0 +1,25 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const joinGroupInviteBoxFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/inv-box/join`);
+    /**
+     * Join group invite box
+     *
+     * @param groupId - The group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function joinGroupInviteBox(groupId) {
+        const params = {
+            grid: groupId,
+            lang: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/joinGroupLink.d.ts

@@ -0,0 +1,2 @@
+export type JoinGroupLinkResponse = "";
+export declare const joinGroupLinkFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (link: string) => Promise<"">;

package/dist/apis/joinGroupLink.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const joinGroupLinkFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/link/join`);
+    /**
+     * Join group via invite link
+     *
+     * @note Zalo might throw an error with code 240 if the group enabled membership approval, 178 if you are already a member.
+     *
+     * @param link - The link join group
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function joinGroupLink(link) {
+        const params = {
+            link: link,
+            clientLang: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/keepAlive.d.ts

@@ -0,0 +1,4 @@
+export type KeepAliveResponse = {
+    config_vesion: number;
+};
+export declare const keepAliveFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => () => Promise<KeepAliveResponse>;

package/dist/apis/keepAlive.js

@@ -0,0 +1,22 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const keepAliveFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.chat[0]}/keepalive`);
+    /**
+     * Keep Alive?
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function keepAlive() {
+        const params = {
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response, undefined, false);
+    };
+});

package/dist/apis/lastOnline.d.ts

@@ -0,0 +1,7 @@
+export type LastOnlineResponse = {
+    settings: {
+        show_online_status: boolean;
+    };
+    lastOnline: number;
+};
+export declare const lastOnlineFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (uid: string) => Promise<LastOnlineResponse>;

package/dist/apis/lastOnline.js

@@ -0,0 +1,26 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const lastOnlineFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/lastOnline`);
+    /**
+     * Get last online
+     *
+     * @param uid User ID
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function lastOnline(uid) {
+        const params = {
+            uid: uid,
+            conv_type: 1,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/leaveGroup.d.ts

@@ -0,0 +1,4 @@
+export type LeaveGroupResponse = {
+    memberError: unknown[];
+};
+export declare const leaveGroupFactory: (ctx: import("../context.js").ContextBase, api: import("../apis.js").API) => (groupId: string, silent?: boolean) => Promise<LeaveGroupResponse>;

package/dist/apis/leaveGroup.js

@@ -0,0 +1,33 @@
+import { ZaloApiError } from "../Errors/ZaloApiError.js";
+import { apiFactory } from "../utils.js";
+export const leaveGroupFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/group/leave`);
+    /**
+     * Leave group
+     *
+     * @param groupId - groupId to leave
+     * @param silent - Turn on/off silent leave group
+     *
+     * @note Zalo might throw an error with code 166 if you are not a member of the group
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function leaveGroup(groupId, silent = false) {
+        const requestParams = {
+            grids: [groupId], // API only supports leaving one group at a time
+            imei: ctx.imei,
+            silent: silent ? 1 : 0,
+            language: ctx.language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/listen.d.ts

@@ -0,0 +1,102 @@
+import EventEmitter from "events";
+import { type FriendEvent } from "../models/FriendEvent.js";
+import { type GroupEvent } from "../models/GroupEvent.js";
+import type { Message, Typing } from "../models/index.js";
+import { Reaction, Undo, ThreadType } from "../models/index.js";
+import type { ContextSession } from "../context.js";
+import { type SeenMessage } from "../models/SeenMessage.js";
+import { type DeliveredMessage } from "../models/DeliveredMessage.js";
+type UploadEventData = {
+    fileUrl: string;
+    fileId: string;
+};
+export type WsPayload<T = Record<string, unknown>> = {
+    version: number;
+    cmd: number;
+    subCmd: number;
+    data: T;
+};
+export type OnMessageCallback = (message: Message) => unknown;
+export type OnClosedCallback = (code: CloseReason, reason: string) => unknown;
+export type OnErrorCallback = (error: unknown) => unknown;
+export declare enum CloseReason {
+    ManualClosure = 1000,
+    AbnormalClosure = 1006,
+    DuplicateConnection = 3000,
+    KickConnection = 3003
+}
+interface ListenerEvents {
+    connected: [];
+    disconnected: [code: CloseReason, reason: string];
+    closed: [code: CloseReason, reason: string];
+    error: [error: unknown];
+    typing: [typing: Typing];
+    message: [message: Message];
+    old_messages: [messages: Message[], type: ThreadType];
+    seen_messages: [messages: SeenMessage[]];
+    delivered_messages: [messages: DeliveredMessage[]];
+    reaction: [reaction: Reaction];
+    old_reactions: [reactions: Reaction[], isGroup: boolean];
+    upload_attachment: [data: UploadEventData];
+    undo: [data: Undo];
+    friend_event: [data: FriendEvent];
+    group_event: [data: GroupEvent];
+    cipher_key: [key: string];
+}
+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 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 canRetry;
+    private shouldRotate;
+    private rotateEndpoint;
+    start({ retryOnClose }?: {
+        retryOnClose?: boolean;
+    }): void;
+    stop(): void;
+    sendWs(payload: WsPayload, requireId?: boolean): void;
+    /**
+     * Request old messages
+     *
+     * @param lastMsgId
+     */
+    requestOldMessages(threadType: ThreadType, lastMsgId?: string | null): void;
+    /**
+     * Request old messages
+     *
+     * @param lastMsgId
+     */
+    requestOldReactions(threadType: ThreadType, lastMsgId?: string | null): void;
+    private reset;
+}
+export {};