@droppii-org/chat-sdk 0.1.71 → 0.1.73

package/dist/src/hooks/conversation/useCreateConversation.js

@@ -0,0 +1,15 @@
+"use client";
+import { useMutation } from "@tanstack/react-query";
+import useAuthStore from "../../store/auth";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import { QUERY_KEYS } from "../../services/query";
+export const useCreateConversation = () => {
+    return useMutation({
+        mutationKey: [QUERY_KEYS.CREATE_CONVERSATION],
+        mutationFn: async (input) => {
+            const res = await apiInstance.post(ENDPOINTS.chatService.createConversation, Object.assign(Object.assign({}, input), { applicationType: useAuthStore.getState().applicationType }));
+            return res.data.data;
+        },
+    });
+};

package/dist/src/hooks/conversation/useResetBotFlow.d.ts

@@ -0,0 +1,3 @@
+import type { BotConversationDetail } from "../../types/conversation";
+export declare const useResetBotFlow: () => import("@tanstack/react-query").UseMutationResult<BotConversationDetail, Error, string, unknown>;
+//# sourceMappingURL=useResetBotFlow.d.ts.map

package/dist/src/hooks/conversation/useResetBotFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResetBotFlow.d.ts","sourceRoot":"","sources":["../../../../src/hooks/conversation/useResetBotFlow.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAElE,eAAO,MAAM,eAAe,wGAY3B,CAAC"}

package/dist/src/hooks/conversation/useResetBotFlow.js

@@ -0,0 +1,14 @@
+"use client";
+import { useMutation } from "@tanstack/react-query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import { QUERY_KEYS } from "../../services/query";
+export const useResetBotFlow = () => {
+    return useMutation({
+        mutationKey: [QUERY_KEYS.RESET_BOT_FLOW],
+        mutationFn: async (conversationId) => {
+            const res = await apiInstance.post(ENDPOINTS.chatService.resetBotFlow(conversationId));
+            return res.data.data;
+        },
+    });
+};

package/dist/src/hooks/conversation/useResolveConversation.d.ts

@@ -0,0 +1,11 @@
+export interface UseResolveConversationParams {
+    conversationId?: string;
+    userId?: string;
+    groupId?: string;
+    botId?: string;
+}
+export declare const useResolveConversation: ({ conversationId, userId, groupId, botId, }: UseResolveConversationParams) => {
+    isResolving: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=useResolveConversation.d.ts.map

package/dist/src/hooks/conversation/useResolveConversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResolveConversation.d.ts","sourceRoot":"","sources":["../../../../src/hooks/conversation/useResolveConversation.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,4BAA4B;IAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAOD,eAAO,MAAM,sBAAsB,GAAI,6CAKpC,4BAA4B;;;CAmG9B,CAAC"}

package/dist/src/hooks/conversation/useResolveConversation.js

@@ -0,0 +1,90 @@
+"use client";
+import { useEffect, useState } from "react";
+import { SessionType } from "@openim/wasm-client-sdk";
+import { DChatSDK } from "../../constants/sdk";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import useConversationStore from "../../store/conversation";
+import { resolveConversationBotId } from "../../utils/conversation";
+export const useResolveConversation = ({ conversationId, userId, groupId, botId, }) => {
+    const [isResolving, setIsResolving] = useState(false);
+    const [error, setError] = useState(null);
+    const conversationData = useConversationStore((state) => state.conversationData);
+    const setConversationData = useConversationStore((state) => state.setConversationData);
+    const setSelectedConversationId = useConversationStore((state) => state.setSelectedConversationId);
+    const hasTarget = !!(conversationId || userId || groupId || botId);
+    const matchesConversationId = !!conversationId && (conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID) === conversationId;
+    const matchesUserId = !!userId && (conversationData === null || conversationData === void 0 ? void 0 : conversationData.userID) === userId;
+    const matchesGroupId = !!groupId && (conversationData === null || conversationData === void 0 ? void 0 : conversationData.groupID) === groupId;
+    const matchesBotId = !!botId &&
+        !!conversationData &&
+        resolveConversationBotId(conversationData) === botId;
+    const isAlreadyResolved = matchesConversationId || matchesUserId || matchesGroupId || matchesBotId;
+    useEffect(() => {
+        if (!hasTarget || isAlreadyResolved)
+            return;
+        let cancelled = false;
+        setIsResolving(true);
+        setError(null);
+        const resolve = async () => {
+            var _a, _b;
+            try {
+                let resolved = null;
+                if (conversationId) {
+                    const { data } = await DChatSDK.getMultipleConversation([conversationId]);
+                    resolved = (_a = data === null || data === void 0 ? void 0 : data[0]) !== null && _a !== void 0 ? _a : null;
+                }
+                else if (userId || groupId) {
+                    const { data } = await DChatSDK.getOneConversation({
+                        sourceID: (userId || groupId),
+                        sessionType: userId ? SessionType.Single : SessionType.Group,
+                    });
+                    resolved = data;
+                }
+                else if (botId) {
+                    const { data: botConversationResponse } = await apiInstance.get(ENDPOINTS.chatService.getConversationByBotId(botId));
+                    const resolvedGroupId = (_b = botConversationResponse.data) === null || _b === void 0 ? void 0 : _b.groupId;
+                    if (!resolvedGroupId) {
+                        throw new Error("Missing groupId from get-or-create bot conversation response");
+                    }
+                    const { data: conversation } = await DChatSDK.getOneConversation({
+                        sourceID: resolvedGroupId,
+                        sessionType: SessionType.Group,
+                    });
+                    resolved = conversation;
+                }
+                if (cancelled)
+                    return;
+                if (!resolved) {
+                    throw new Error("Conversation not found");
+                }
+                setConversationData(resolved);
+                setSelectedConversationId(resolved.conversationID);
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                console.error("useResolveConversation", err);
+                setError(err instanceof Error ? err : new Error("Failed to resolve conversation"));
+            }
+            finally {
+                if (!cancelled)
+                    setIsResolving(false);
+            }
+        };
+        void resolve();
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        conversationId,
+        userId,
+        groupId,
+        botId,
+        hasTarget,
+        isAlreadyResolved,
+        setConversationData,
+        setSelectedConversationId,
+    ]);
+    return { isResolving, error };
+};

package/dist/src/hooks/conversation/useRunBotFlow.d.ts

@@ -0,0 +1,7 @@
+import type { BotFlowMeta } from "../../types/chat";
+import type { RunBotFlowResponse } from "../../types/conversation";
+export interface RunBotFlowParams extends BotFlowMeta {
+    conversationId: string;
+}
+export declare const useRunBotFlow: () => import("@tanstack/react-query").UseMutationResult<RunBotFlowResponse, Error, RunBotFlowParams, unknown>;
+//# sourceMappingURL=useRunBotFlow.d.ts.map

package/dist/src/hooks/conversation/useRunBotFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRunBotFlow.d.ts","sourceRoot":"","sources":["../../../../src/hooks/conversation/useRunBotFlow.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,aAAa,+GAgBzB,CAAC"}

package/dist/src/hooks/conversation/useRunBotFlow.js

@@ -0,0 +1,14 @@
+"use client";
+import { useMutation } from "@tanstack/react-query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import { QUERY_KEYS } from "../../services/query";
+export const useRunBotFlow = () => {
+    return useMutation({
+        mutationKey: [QUERY_KEYS.RUN_BOT_FLOW],
+        mutationFn: async ({ conversationId, groupId, childId, actionId, }) => {
+            const res = await apiInstance.post(ENDPOINTS.chatService.runBotFlow(conversationId), { groupId, childId, actionId });
+            return res.data.data;
+        },
+    });
+};

package/dist/src/hooks/conversation/useSwitchToCsTeam.d.ts

@@ -0,0 +1,11 @@
+export declare const SwitchToCsTeamResult: {
+    readonly AlreadyInCs: "already_in_cs";
+    readonly Switched: "switched";
+    readonly Failed: "failed";
+};
+export type SwitchToCsTeamResult = (typeof SwitchToCsTeamResult)[keyof typeof SwitchToCsTeamResult];
+export declare const useSwitchToCsTeam: () => {
+    switchToCsTeam: (conversationId: string) => Promise<SwitchToCsTeamResult>;
+    isPending: boolean;
+};
+//# sourceMappingURL=useSwitchToCsTeam.d.ts.map

package/dist/src/hooks/conversation/useSwitchToCsTeam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSwitchToCsTeam.d.ts","sourceRoot":"","sources":["../../../../src/hooks/conversation/useSwitchToCsTeam.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAC9B,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAEnE,eAAO,MAAM,iBAAiB;qCAKH,MAAM,KAAG,OAAO,CAAC,oBAAoB,CAAC;;CAuChE,CAAC"}

package/dist/src/hooks/conversation/useSwitchToCsTeam.js

@@ -0,0 +1,46 @@
+"use client";
+import { useCallback } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { QUERY_KEYS } from "../../services/query";
+import { BOT_COMMAND_CHAT_WITH_CS } from "../../constants/botFlow";
+import { isInCsSession, findMainMenuAction } from "../../utils/botFlow";
+import { fetchBotConversationDetail } from "./useBotConversationDetail";
+import { fetchBotMainMenu } from "./useBotMainMenu";
+import { useRunBotFlow } from "./useRunBotFlow";
+export const SwitchToCsTeamResult = {
+    AlreadyInCs: "already_in_cs",
+    Switched: "switched",
+    Failed: "failed",
+};
+export const useSwitchToCsTeam = () => {
+    const queryClient = useQueryClient();
+    const { mutateAsync: runBotFlow, isPending } = useRunBotFlow();
+    const switchToCsTeam = useCallback(async (conversationId) => {
+        try {
+            const detail = await fetchBotConversationDetail(conversationId);
+            if (isInCsSession(detail)) {
+                return SwitchToCsTeamResult.AlreadyInCs;
+            }
+            const mainMenu = await fetchBotMainMenu(conversationId);
+            const chatWithCsAction = findMainMenuAction(mainMenu, BOT_COMMAND_CHAT_WITH_CS);
+            if (!chatWithCsAction) {
+                return SwitchToCsTeamResult.Failed;
+            }
+            await runBotFlow({
+                conversationId,
+                groupId: "",
+                childId: "",
+                actionId: chatWithCsAction.id,
+            });
+            await queryClient.invalidateQueries({
+                queryKey: [QUERY_KEYS.GET_CONVERSATION_DETAIL, conversationId],
+            });
+            return SwitchToCsTeamResult.Switched;
+        }
+        catch (error) {
+            console.error("switchToCsTeam", error);
+            return SwitchToCsTeamResult.Failed;
+        }
+    }, [runBotFlow, queryClient]);
+    return { switchToCsTeam, isPending };
+};

package/dist/src/hooks/global/useGlobalEvent.d.ts

@@ -0,0 +1,2 @@
+export declare const useGlobalEvent: () => void;
+//# sourceMappingURL=useGlobalEvent.d.ts.map

package/dist/src/hooks/global/useGlobalEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGlobalEvent.d.ts","sourceRoot":"","sources":["../../../../src/hooks/global/useGlobalEvent.ts"],"names":[],"mappings":"AAqCA,eAAO,MAAM,cAAc,YA8U1B,CAAC"}

package/dist/src/hooks/global/useGlobalEvent.js

@@ -0,0 +1,286 @@
+import { useEffect } from "react";
+import { useLatest } from "ahooks";
+import { DChatSDK } from "../../constants/sdk";
+import { CbEvents, MessageType, SessionType, } from "@openim/wasm-client-sdk";
+import { BusinessNotificationType, ConnectStatus, CustomType, SyncStatus, } from "../../types/chat";
+import { pushNewMessage, updateOneMessage } from "../../hooks/message/useMessage";
+import { fetchPinnedMessages } from "../../hooks/message/usePinnedMessages";
+import { applyRevokedMessage } from "../../hooks/message/useRevokeMessage";
+import { useChatContext } from "../../context/ChatContext";
+import useConversationStore from "../../store/conversation";
+import useAuthStore from "../../store/auth";
+import { useRefetchChatToken } from "../../hooks/init/useChatToken";
+import { updateSession } from "../../hooks/session/useUpdateSession";
+import { QUERY_KEYS } from "../../services/query";
+import { useQueryClient } from "@tanstack/react-query";
+import { isGroupSession } from "../../utils/imCommon";
+import { invalidateSessionQueries } from "../../utils/queryHelpers";
+import emitter from "../../utils/events";
+const notPushType = [MessageType.TypingMessage, MessageType.RevokeMessage];
+export const useGlobalEvent = () => {
+    const { user } = useChatContext();
+    const userRef = useLatest(user);
+    const queryClient = useQueryClient();
+    const { updateConnectStatus, updateSyncStatus, getSelfUserInfo } = useChatContext();
+    const updateConversationList = useConversationStore((state) => state.updateConversationList);
+    const getConversationListByReq = useConversationStore((state) => state.getConversationListByReq);
+    const getCurrentGroupInfoByReq = useConversationStore((state) => state.getCurrentGroupInfoByReq);
+    const getCurrentMemberInGroupByReq = useConversationStore((state) => state.getCurrentMemberInGroupByReq);
+    const { mutate: refetchChatToken } = useRefetchChatToken();
+    const accessToken = useAuthStore((state) => state.accessToken);
+    const chatToken = useAuthStore((state) => state.chatToken);
+    const userID = useAuthStore((state) => state.userID);
+    const apiAddress = useAuthStore((state) => {
+        return state.apiAddress;
+    });
+    const refreshCurrentGroupState = async () => {
+        const currentConversation = useConversationStore.getState().currentConversation;
+        if (!(currentConversation === null || currentConversation === void 0 ? void 0 : currentConversation.groupID) ||
+            !isGroupSession(currentConversation.conversationType)) {
+            return;
+        }
+        await Promise.all([
+            getCurrentGroupInfoByReq(currentConversation.groupID),
+            getCurrentMemberInGroupByReq(currentConversation.groupID),
+        ]);
+    };
+    const revokedMessageHandler = ({ data }) => {
+        applyRevokedMessage(data.clientMsgID);
+    };
+    const messagePinnedHandler = ({ data }) => {
+        updateOneMessage({
+            clientMsgID: data.clientMsgID,
+            isPinned: data.isPinned,
+            pinnedByUserID: data.operatorUserID,
+            pinnedTime: data.pinnedTime,
+        });
+        const { selectedConversationId, conversationData } = useConversationStore.getState();
+        const currentConversationId = selectedConversationId || (conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID);
+        if (currentConversationId === data.conversationID) {
+            void fetchPinnedMessages(data.conversationID);
+        }
+    };
+    const inCurrentConversation = (newServerMsg) => {
+        var _a;
+        const selectedSourceId = useConversationStore.getState().selectedSourceId;
+        switch (newServerMsg.sessionType) {
+            case SessionType.Single:
+                return (newServerMsg.sendID === selectedSourceId ||
+                    !!(((_a = userRef.current) === null || _a === void 0 ? void 0 : _a.userID) && newServerMsg.recvID === selectedSourceId));
+            case SessionType.Group:
+            case SessionType.WorkingGroup:
+                return newServerMsg.groupID === selectedSourceId;
+            case SessionType.Notification:
+                return newServerMsg.sendID === selectedSourceId;
+            default:
+                return false;
+        }
+    };
+    const handleNewMessage = (newServerMsg) => {
+        var _a, _b, _c;
+        let customData = null;
+        if (newServerMsg.contentType === MessageType.CustomMessage) {
+            const rawCustomData = (_b = (_a = newServerMsg.customElem) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.trim();
+            if (rawCustomData === null || rawCustomData === void 0 ? void 0 : rawCustomData.startsWith("{")) {
+                try {
+                    customData = JSON.parse(rawCustomData);
+                }
+                catch (e) {
+                    console.error("Failed to parse custom message data", e);
+                }
+            }
+            if (customData &&
+                CustomType.CallingInvite <= customData.customType &&
+                customData.customType <= CustomType.CallingHungup) {
+                return;
+            }
+        }
+        if (!inCurrentConversation(newServerMsg))
+            return;
+        if (!notPushType.includes(newServerMsg.contentType)) {
+            pushNewMessage(newServerMsg);
+        }
+        if (newServerMsg.sendID !== ((_c = userRef.current) === null || _c === void 0 ? void 0 : _c.userID)) {
+            queryClient.invalidateQueries({
+                queryKey: [QUERY_KEYS.GET_LIST_SESSION_BY_CONVERSATION],
+            });
+            void invalidateSessionQueries(queryClient);
+        }
+    };
+    const newMessageHandler = ({ data }) => {
+        var _a;
+        (_a = data === null || data === void 0 ? void 0 : data.map) === null || _a === void 0 ? void 0 : _a.call(data, (message) => handleNewMessage(message));
+    };
+    const userTokenHandler = () => {
+        refetchChatToken(undefined, {
+            onSettled(data) {
+                var _a;
+                if (data) {
+                    useAuthStore.getState().setChatToken((_a = data === null || data === void 0 ? void 0 : data.data) === null || _a === void 0 ? void 0 : _a.token);
+                }
+            },
+        });
+    };
+    const loadConversationList = () => {
+        const { isCrm, applicationType } = useAuthStore.getState();
+        getConversationListByReq(false, isCrm ? undefined : { applicationType });
+    };
+    const initStore = () => {
+        loadConversationList();
+    };
+    const tryLogin = async () => {
+        const { userID, chatToken, platformID, wsAddress } = useAuthStore.getState();
+        try {
+            await DChatSDK.login({
+                userID,
+                token: chatToken,
+                platformID,
+                apiAddr: `${apiAddress}/chat-service`,
+                wsAddr: `${wsAddress}/chat-service/ws`,
+            });
+            initStore();
+        }
+        catch (error) {
+            if (error.errCode === 10102) {
+                updateConnectStatus(ConnectStatus.Connected);
+                updateSyncStatus(SyncStatus.Success);
+                getSelfUserInfo();
+                initStore();
+                return;
+            }
+            console.error(error);
+        }
+    };
+    const loginCheck = async () => {
+        const chatToken = useAuthStore.getState().chatToken;
+        const userID = useAuthStore.getState().userID;
+        if (!chatToken || !userID) {
+            return;
+        }
+        tryLogin();
+    };
+    const connectingHandler = () => {
+        updateConnectStatus(ConnectStatus.Connecting);
+    };
+    const connectSuccessHandler = () => {
+        updateConnectStatus(ConnectStatus.Connected);
+    };
+    const connectFailedHandler = () => {
+        updateConnectStatus(ConnectStatus.Disconnected);
+    };
+    const syncStartHandler = ({ data }) => {
+        updateSyncStatus(SyncStatus.Loading);
+    };
+    const syncFinishHandler = () => {
+        updateSyncStatus(SyncStatus.Success);
+        getSelfUserInfo();
+        loadConversationList();
+        void refreshCurrentGroupState();
+    };
+    const syncFailedHandler = () => {
+        updateSyncStatus(SyncStatus.Failed);
+    };
+    const businessNotificationHandler = ({ data, }) => {
+        console.log(data.key, "business notification");
+        switch (data.key) {
+            case BusinessNotificationType.SESSION_STATE_UPDATED:
+                updateSession(JSON.parse(data.data || "{}"));
+                break;
+            case BusinessNotificationType.SESSION_CREATED:
+                updateSession(JSON.parse(data.data || "{}"));
+                queryClient.invalidateQueries({
+                    queryKey: [QUERY_KEYS.GET_LIST_SESSION_BY_CONVERSATION],
+                });
+                break;
+            default:
+                break;
+        }
+    };
+    const groupMemberChangedHandler = () => {
+        void refreshCurrentGroupState();
+        emitter.emit("GROUP_MEMBERS_CHANGED");
+    };
+    const setIMListener = () => {
+        //account
+        DChatSDK.on(CbEvents.OnUserTokenExpired, userTokenHandler);
+        DChatSDK.on(CbEvents.OnUserTokenInvalid, userTokenHandler);
+        DChatSDK.on(CbEvents.OnConnecting, connectingHandler);
+        DChatSDK.on(CbEvents.OnConnectSuccess, connectSuccessHandler);
+        DChatSDK.on(CbEvents.OnConnectFailed, connectFailedHandler);
+        // sync
+        DChatSDK.on(CbEvents.OnSyncServerStart, syncStartHandler);
+        // DChatSDK.on(CbEvents.OnSyncServerProgress, syncProgressHandler);
+        DChatSDK.on(CbEvents.OnSyncServerFinish, syncFinishHandler);
+        DChatSDK.on(CbEvents.OnSyncServerFailed, syncFailedHandler);
+        // message
+        DChatSDK.on(CbEvents.OnRecvNewMessages, newMessageHandler);
+        DChatSDK.on(CbEvents.OnNewRecvMessageRevoked, revokedMessageHandler);
+        DChatSDK.on(CbEvents.OnRecvMessagePinned, messagePinnedHandler);
+        // conversation
+        DChatSDK.on(CbEvents.OnConversationChanged, conversationChangeHandler);
+        DChatSDK.on(CbEvents.OnNewConversation, newConversationHandler);
+        // group members
+        DChatSDK.on(CbEvents.OnGroupMemberAdded, groupMemberChangedHandler);
+        DChatSDK.on(CbEvents.OnGroupMemberDeleted, groupMemberChangedHandler);
+        //busines notification
+        DChatSDK.on(CbEvents.OnRecvCustomBusinessMessage, businessNotificationHandler);
+    };
+    const disposeIMListener = () => {
+        //account
+        DChatSDK.off(CbEvents.OnUserTokenExpired, userTokenHandler);
+        DChatSDK.off(CbEvents.OnUserTokenInvalid, userTokenHandler);
+        DChatSDK.off(CbEvents.OnConnecting, connectingHandler);
+        DChatSDK.off(CbEvents.OnConnectSuccess, connectSuccessHandler);
+        DChatSDK.off(CbEvents.OnConnectFailed, connectFailedHandler);
+        // sync
+        DChatSDK.off(CbEvents.OnSyncServerStart, syncStartHandler);
+        // DChatSDK.off(CbEvents.OnSyncServerProgress, syncProgressHandler);
+        DChatSDK.off(CbEvents.OnSyncServerFinish, syncFinishHandler);
+        DChatSDK.off(CbEvents.OnSyncServerFailed, syncFailedHandler);
+        // message
+        DChatSDK.off(CbEvents.OnRecvNewMessages, newMessageHandler);
+        DChatSDK.off(CbEvents.OnNewRecvMessageRevoked, revokedMessageHandler);
+        DChatSDK.off(CbEvents.OnRecvMessagePinned, messagePinnedHandler);
+        // conversation
+        DChatSDK.off(CbEvents.OnConversationChanged, conversationChangeHandler);
+        DChatSDK.off(CbEvents.OnNewConversation, newConversationHandler);
+        // group members
+        DChatSDK.off(CbEvents.OnGroupMemberAdded, groupMemberChangedHandler);
+        DChatSDK.off(CbEvents.OnGroupMemberDeleted, groupMemberChangedHandler);
+        //busines notification
+        DChatSDK.off(CbEvents.OnRecvCustomBusinessMessage, businessNotificationHandler);
+    };
+    // conversation
+    const conversationChangeHandler = ({ data }) => {
+        updateConversationList(data, "filter");
+        void refreshCurrentGroupState();
+    };
+    const newConversationHandler = ({ data }) => {
+        updateConversationList(data, "push");
+        void refreshCurrentGroupState();
+    };
+    /** LIFE CYCLE */
+    useEffect(() => {
+        setIMListener();
+        window.addEventListener("online", () => {
+            DChatSDK.networkStatusChanged();
+        });
+        window.addEventListener("offline", () => {
+            DChatSDK.networkStatusChanged();
+        });
+        return () => {
+            disposeIMListener();
+        };
+    }, []);
+    useEffect(() => {
+        if (!!accessToken && apiAddress) {
+            userTokenHandler();
+        }
+    }, [accessToken, apiAddress]);
+    useEffect(() => {
+        if (!chatToken || !apiAddress || !userID) {
+            return;
+        }
+        loginCheck();
+    }, [chatToken, apiAddress, userID]);
+};

package/dist/src/hooks/group/useGroupMembers.d.ts

@@ -0,0 +1,10 @@
+import { GroupMemberItem } from "@openim/wasm-client-sdk";
+interface UseGroupMembersResult {
+    members: GroupMemberItem[];
+    isLoading: boolean;
+    error?: string;
+    refetch: () => Promise<void>;
+}
+export declare const useGroupMembers: (groupID?: string) => UseGroupMembersResult;
+export {};
+//# sourceMappingURL=useGroupMembers.d.ts.map

package/dist/src/hooks/group/useGroupMembers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGroupMembers.d.ts","sourceRoot":"","sources":["../../../../src/hooks/group/useGroupMembers.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,eAAe,EAAW,MAAM,yBAAyB,CAAC;AAM7E,UAAU,qBAAqB;IAC7B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,KACf,qBA+DF,CAAC"}

package/dist/src/hooks/group/useGroupMembers.js

@@ -0,0 +1,61 @@
+import { useCallback, useEffect, useState } from "react";
+import { CbEvents } from "@openim/wasm-client-sdk";
+import { DChatSDK } from "../../constants/sdk";
+const GROUP_MEMBER_LIST_OFFSET = 0;
+const GROUP_MEMBER_LIST_COUNT = 999;
+export const useGroupMembers = (groupID) => {
+    const [members, setMembers] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(undefined);
+    const fetchMembers = useCallback(async () => {
+        if (!groupID) {
+            setMembers([]);
+            setError(undefined);
+            return;
+        }
+        setIsLoading(true);
+        setError(undefined);
+        try {
+            const { data } = await DChatSDK.getGroupMemberList({
+                groupID,
+                filter: 0,
+                offset: GROUP_MEMBER_LIST_OFFSET,
+                count: GROUP_MEMBER_LIST_COUNT,
+            });
+            setMembers(data !== null && data !== void 0 ? data : []);
+        }
+        catch (err) {
+            console.error("Error fetching group member list:", err);
+            setMembers([]);
+            setError("load_group_member_list_failed");
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [groupID]);
+    useEffect(() => {
+        void fetchMembers();
+    }, [fetchMembers]);
+    useEffect(() => {
+        if (!groupID)
+            return;
+        const onMemberDeleted = ({ data }) => {
+            if (data.groupID === groupID) {
+                setMembers((prev) => prev.filter((m) => m.userID !== data.userID));
+            }
+        };
+        const onMemberAdded = () => void fetchMembers();
+        DChatSDK.on(CbEvents.OnGroupMemberDeleted, onMemberDeleted);
+        DChatSDK.on(CbEvents.OnGroupMemberAdded, onMemberAdded);
+        return () => {
+            DChatSDK.off(CbEvents.OnGroupMemberDeleted, onMemberDeleted);
+            DChatSDK.off(CbEvents.OnGroupMemberAdded, onMemberAdded);
+        };
+    }, [groupID, fetchMembers]);
+    return {
+        members,
+        isLoading,
+        error,
+        refetch: fetchMembers,
+    };
+};

package/dist/src/hooks/init/useChatToken.d.ts

@@ -0,0 +1,2 @@
+export declare const useRefetchChatToken: () => import("@tanstack/react-query").UseMutationResult<any, Error, void, unknown>;
+//# sourceMappingURL=useChatToken.d.ts.map

package/dist/src/hooks/init/useChatToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChatToken.d.ts","sourceRoot":"","sources":["../../../../src/hooks/init/useChatToken.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB,oFAS5B,CAAC"}

package/dist/src/hooks/init/useChatToken.js

@@ -0,0 +1,11 @@
+import { useMutation } from "@tanstack/react-query";
+import { QUERY_KEYS } from "../../services/query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+export const useRefetchChatToken = () => useMutation({
+    mutationKey: [QUERY_KEYS.REFRESH_CHAT_TOKEN],
+    mutationFn: async () => {
+        const res = await apiInstance.post(ENDPOINTS.chatService.getChatToken);
+        return res.data;
+    },
+});

package/dist/src/hooks/message/useConversationMessages.d.ts

@@ -0,0 +1,27 @@
+import { MessageItem } from "@openim/wasm-client-sdk";
+interface UseConversationMessagesParams {
+    conversationId?: string;
+    searchClientMsgID?: string;
+    restrictToLastSession?: boolean;
+    customerUserID?: string;
+}
+export declare const useConversationMessages: ({ conversationId, searchClientMsgID, restrictToLastSession, customerUserID, }: UseConversationMessagesParams) => {
+    loadState: {
+        initLoading: boolean;
+        hasMoreOld: boolean;
+        hasMoreNew: boolean;
+        messageList: MessageItem[];
+    };
+    latestLoadState: import("react").RefObject<{
+        initLoading: boolean;
+        hasMoreOld: boolean;
+        hasMoreNew: boolean;
+        messageList: MessageItem[];
+    }>;
+    moreOldLoading: boolean;
+    getMoreOldMessages: (loadMore?: any) => Promise<void>;
+    moreNewLoading: boolean;
+    getMoreNewMessages: (loadMore?: any) => Promise<void>;
+};
+export {};
+//# sourceMappingURL=useConversationMessages.d.ts.map

package/dist/src/hooks/message/useConversationMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversationMessages.d.ts","sourceRoot":"","sources":["../../../../src/hooks/message/useConversationMessages.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,UAAU,6BAA6B;IACrC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,uBAAuB,GAAI,+EAKrC,6BAA6B;;;;;;;;;;;;;;;;;CAwC/B,CAAC"}