@droppii-org/chat-sdk 0.1.72 → 0.1.73

package/dist/src/hooks/message/useConversationMessages.js

@@ -0,0 +1,30 @@
+"use client";
+import { useMemo } from "react";
+import { useMessage } from "./useMessage";
+import { usePullSessionMessages } from "./usePullSessionMessages";
+export const useConversationMessages = ({ conversationId, searchClientMsgID, restrictToLastSession = false, customerUserID, }) => {
+    const isPreviewMessagesBeforeJoin = restrictToLastSession;
+    const sdkMessages = useMessage(conversationId, searchClientMsgID, !isPreviewMessagesBeforeJoin);
+    const { data: pulledMessages, isLoading: isPullLoading, isFetching: isPullFetching, } = usePullSessionMessages({
+        conversationID: conversationId,
+        userID: customerUserID,
+        enabled: isPreviewMessagesBeforeJoin,
+    });
+    const lastSessionState = useMemo(() => ({
+        initLoading: isPullLoading || isPullFetching,
+        hasMoreOld: false,
+        hasMoreNew: false,
+        messageList: pulledMessages !== null && pulledMessages !== void 0 ? pulledMessages : [],
+    }), [isPullLoading, isPullFetching, pulledMessages]);
+    if (isPreviewMessagesBeforeJoin) {
+        return {
+            loadState: lastSessionState,
+            latestLoadState: { current: lastSessionState },
+            moreOldLoading: false,
+            getMoreOldMessages: async () => undefined,
+            moreNewLoading: false,
+            getMoreNewMessages: async () => undefined,
+        };
+    }
+    return sdkMessages;
+};

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

@@ -0,0 +1,26 @@
+import { MessageItem, MessageType } from "@openim/wasm-client-sdk";
+export declare const visibleTypeMessage: MessageType[];
+export declare const isMessageHiddenForViewer: (message: MessageItem, isCrm: boolean) => boolean;
+export declare const useMessage: (conversationId?: string, searchClientMsgID?: string, enabled?: boolean, useAppHistory?: boolean) => {
+    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 declare const pushNewMessage: (message: MessageItem) => void;
+export declare const updateOneMessage: (message: MessageItem) => void;
+export declare const removeOneMessage: (clientMsgID: string) => void;
+export declare const getVisibleNeighbor: (allMessages: MessageItem[], current: MessageItem, direction: "prev" | "next") => MessageItem | undefined;
+//# sourceMappingURL=useMessage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMessage.d.ts","sourceRoot":"","sources":["../../../../src/hooks/message/useMessage.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,WAAW,EACX,WAAW,EAEZ,MAAM,yBAAyB,CAAC;AAYjC,eAAO,MAAM,kBAAkB,eAgB9B,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,SAAS,WAAW,EACpB,OAAO,OAAO,KACb,OAWF,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,iBAAiB,MAAM,EACvB,oBAAoB,MAAM,EAC1B,iBAAc,EACd,uBAAqB;;;;;qBAeA,WAAW,EAAE;;;;;;qBAAb,WAAW,EAAE;;;;;;CAsSnC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,SAAS,WAAW,SACpB,CAAC;AAChC,eAAO,MAAM,gBAAgB,GAAI,SAAS,WAAW,SACpB,CAAC;AAClC,eAAO,MAAM,gBAAgB,GAAI,aAAa,MAAM,SACf,CAAC;AAEtC,eAAO,MAAM,kBAAkB,GAC7B,aAAa,WAAW,EAAE,EAC1B,SAAS,WAAW,EACpB,WAAW,MAAM,GAAG,MAAM,KACzB,WAAW,GAAG,SAkBhB,CAAC"}

package/dist/src/hooks/message/useMessage.js

@@ -0,0 +1,320 @@
+import { useEffect, useState } from "react";
+import { ViewType, MessageType, } from "@openim/wasm-client-sdk";
+import { DChatSDK } from "../../constants/sdk";
+import { PAGE_SIZE } from "../../constants";
+import { useLatest, useRequest } from "ahooks";
+import emitter, { emit } from "../../utils/events";
+import isEmpty from "lodash/isEmpty";
+import { useChatContext } from "../../context/ChatContext";
+import useAuthStore from "../../store/auth";
+import { ConnectStatus, SyncStatus } from "../../types/chat";
+import { isSystemLogMessageType } from "../../utils/messageLog";
+import { isRenderableCustomMessage } from "../../utils/customMessage";
+export const visibleTypeMessage = [
+    MessageType.TextMessage,
+    MessageType.PictureMessage,
+    MessageType.VoiceMessage,
+    MessageType.VideoMessage,
+    MessageType.FileMessage,
+    MessageType.AtTextMessage,
+    MessageType.MergeMessage,
+    MessageType.CardMessage,
+    MessageType.LocationMessage,
+    MessageType.CustomMessage,
+    MessageType.QuoteMessage,
+    MessageType.FaceMessage,
+    MessageType.UrlTextMessage,
+    MessageType.RevokeMessage,
+    MessageType.LogTextMessage,
+];
+export const isMessageHiddenForViewer = (message, isCrm) => {
+    if (!visibleTypeMessage.includes(message === null || message === void 0 ? void 0 : message.contentType))
+        return true;
+    if (isCrm)
+        return false;
+    const isCustomMessage = MessageType.CustomMessage === (message === null || message === void 0 ? void 0 : message.contentType);
+    return (Boolean(message === null || message === void 0 ? void 0 : message.isInternal) ||
+        isSystemLogMessageType(message === null || message === void 0 ? void 0 : message.contentType) ||
+        (isCustomMessage && !isRenderableCustomMessage(message)));
+};
+export const useMessage = (conversationId, searchClientMsgID, enabled = true, useAppHistory = false) => {
+    const { connectStatus, syncStatus } = useChatContext();
+    const userID = useAuthStore((state) => state.userID);
+    const canLoad = enabled &&
+        connectStatus === ConnectStatus.Connected &&
+        syncStatus !== SyncStatus.Loading &&
+        !!conversationId &&
+        !!userID;
+    const [loadState, setLoadState] = useState({
+        initLoading: true,
+        hasMoreOld: true,
+        hasMoreNew: false,
+        messageList: [],
+    });
+    const latestLoadState = useLatest(loadState);
+    const canLoadRef = useLatest(canLoad);
+    const conversationIdRef = useLatest(conversationId);
+    const { loading: moreOldLoading, runAsync: getMoreOldMessages } = useRequest(async (loadMore = true) => {
+        var _a, _b, _c, _d, _e;
+        const reqConversationID = conversationId;
+        const params = {
+            count: PAGE_SIZE.large,
+            startClientMsgID: loadMore
+                ? ((_e = (_b = (_a = latestLoadState.current) === null || _a === void 0 ? void 0 : _a.messageList) === null || _b === void 0 ? void 0 : _b[((_d = (_c = latestLoadState.current) === null || _c === void 0 ? void 0 : _c.messageList) === null || _d === void 0 ? void 0 : _d.length) - 1]) === null || _e === void 0 ? void 0 : _e.clientMsgID) || ""
+                : "",
+            conversationID: conversationId !== null && conversationId !== void 0 ? conversationId : "",
+            viewType: ViewType.History,
+        };
+        try {
+            const { data } = useAppHistory
+                ? await DChatSDK.getAdvancedHistoryMessageListApp(params)
+                : await DChatSDK.getAdvancedHistoryMessageList(params);
+            if (conversationIdRef.current !== reqConversationID)
+                return;
+            setTimeout(() => {
+                if (conversationIdRef.current !== reqConversationID)
+                    return;
+                setLoadState((preState) => {
+                    // Always merge with preState (never discard it, even for the
+                    // initial load): a message can arrive via PUSH_NEW_MSG while this
+                    // request is in flight, and dropping preState here would wipe it
+                    // out the moment the fetch resolves. When the same clientMsgID
+                    // shows up in both, prefer the server copy (it carries the real
+                    // status/seq) while keeping the position of its first occurrence.
+                    const messageList = mergePreferringLatest(preState.messageList, data.messageList.toReversed());
+                    return Object.assign(Object.assign({}, preState), { initLoading: false, hasMoreOld: !data.isEnd, messageList });
+                });
+            });
+        }
+        catch (_f) {
+            if (conversationIdRef.current !== reqConversationID)
+                return;
+            setLoadState((preState) => (Object.assign(Object.assign({}, preState), { initLoading: false })));
+        }
+    }, {
+        manual: true,
+    });
+    const { loading: moreNewLoading, runAsync: getMoreNewMessages } = useRequest(async (loadMore = true) => {
+        var _a, _b;
+        const reqConversationID = conversationId;
+        try {
+            const reverseParams = {
+                count: PAGE_SIZE.large,
+                startClientMsgID: loadMore
+                    ? ((_b = (_a = latestLoadState.current) === null || _a === void 0 ? void 0 : _a.messageList[0]) === null || _b === void 0 ? void 0 : _b.clientMsgID) || ""
+                    : "",
+                conversationID: conversationId !== null && conversationId !== void 0 ? conversationId : "",
+                viewType: ViewType.Search,
+            };
+            const { data } = useAppHistory
+                ? await DChatSDK.getAdvancedHistoryMessageListReverseApp(reverseParams)
+                : await DChatSDK.getAdvancedHistoryMessageListReverse(reverseParams);
+            if (conversationIdRef.current !== reqConversationID)
+                return;
+            setTimeout(() => {
+                if (conversationIdRef.current !== reqConversationID)
+                    return;
+                setLoadState((preState) => {
+                    let messageList = [
+                        ...data.messageList.toReversed(),
+                        ...(loadMore ? preState.messageList : []),
+                    ];
+                    messageList = removeDuplicateMessages(messageList);
+                    return Object.assign(Object.assign({}, preState), { initLoading: false, hasMoreNew: !data.isEnd, messageList });
+                });
+            });
+        }
+        catch (_c) {
+            if (conversationIdRef.current !== reqConversationID)
+                return;
+            setLoadState((preState) => (Object.assign(Object.assign({}, preState), { initLoading: false })));
+        }
+    }, {
+        manual: true,
+    });
+    const { runAsync: searchMessages } = useRequest(async () => {
+        var _a, _b;
+        if (!searchClientMsgID || !conversationId)
+            return;
+        const reqConversationID = conversationId;
+        const searchPrevParams = {
+            count: PAGE_SIZE.small,
+            startClientMsgID: searchClientMsgID,
+            conversationID: conversationId !== null && conversationId !== void 0 ? conversationId : "",
+            viewType: ViewType.History,
+        };
+        const searchNextParams = {
+            count: PAGE_SIZE.small,
+            startClientMsgID: searchClientMsgID,
+            conversationID: conversationId !== null && conversationId !== void 0 ? conversationId : "",
+            viewType: ViewType.Search,
+        };
+        const { data: dataPrev } = useAppHistory
+            ? await DChatSDK.getAdvancedHistoryMessageListApp(searchPrevParams)
+            : await DChatSDK.getAdvancedHistoryMessageList(searchPrevParams);
+        const { data: dataNext } = useAppHistory
+            ? await DChatSDK.getAdvancedHistoryMessageListReverseApp(searchNextParams)
+            : await DChatSDK.getAdvancedHistoryMessageListReverse(searchNextParams);
+        const { data: dataCurrent } = await DChatSDK.findMessageList([
+            {
+                conversationID: conversationId !== null && conversationId !== void 0 ? conversationId : "",
+                clientMsgIDList: [searchClientMsgID !== null && searchClientMsgID !== void 0 ? searchClientMsgID : ""],
+            },
+        ]);
+        const currentMessages = ((_b = (_a = dataCurrent === null || dataCurrent === void 0 ? void 0 : dataCurrent.findResultItems) === null || _a === void 0 ? void 0 : _a.find((item) => item.conversationID === conversationId)) === null || _b === void 0 ? void 0 : _b.messageList) || [];
+        if (conversationId !== reqConversationID)
+            return;
+        setTimeout(() => {
+            setLoadState((preState) => {
+                let messageList = [
+                    ...dataNext.messageList.toReversed(),
+                    ...currentMessages,
+                    ...dataPrev.messageList.toReversed(),
+                ];
+                messageList = removeDuplicateMessages(messageList);
+                return Object.assign(Object.assign({}, preState), { initLoading: false, hasMoreOld: !dataPrev.isEnd, hasMoreNew: !dataNext.isEnd, messageList });
+            });
+        });
+        setTimeout(() => {
+            emit("CHAT_LIST_SCROLL_TO_MESSAGE", searchClientMsgID);
+        }, 200);
+    }, {
+        manual: true,
+    });
+    useEffect(() => {
+        const pushNewMessage = (message) => {
+            var _a, _b;
+            if (!canLoadRef.current)
+                return;
+            if ((_b = (_a = latestLoadState.current) === null || _a === void 0 ? void 0 : _a.messageList) === null || _b === void 0 ? void 0 : _b.find((item) => item.clientMsgID === message.clientMsgID)) {
+                return;
+            }
+            setLoadState((preState) => {
+                // sendTime is assigned once at creation (optimistic or server) and
+                // never changes afterwards, so sorting by it keeps messages in the
+                // right order regardless of network delay or how late seq comes back.
+                const messageList = [message, ...preState.messageList].sort((a, b) => (b.sendTime || 0) - (a.sendTime || 0));
+                return Object.assign(Object.assign({}, preState), { messageList });
+            });
+        };
+        const updateOneMessage = (message) => {
+            if (!canLoadRef.current)
+                return;
+            setLoadState((preState) => {
+                var _a, _b, _c, _d;
+                const tmpList = [...preState.messageList];
+                const idx = tmpList.findIndex((msg) => msg.clientMsgID === message.clientMsgID);
+                if (idx < 0) {
+                    return preState;
+                }
+                const isRevoked = message.contentType === MessageType.RevokeMessage;
+                if (isRevoked) {
+                    const relatedQuoteMessageIds = (_a = tmpList === null || tmpList === void 0 ? void 0 : tmpList.filter((msg) => {
+                        var _a, _b;
+                        return (msg === null || msg === void 0 ? void 0 : msg.contentType) === MessageType.QuoteMessage &&
+                            ((_b = (_a = msg === null || msg === void 0 ? void 0 : msg.quoteElem) === null || _a === void 0 ? void 0 : _a.quoteMessage) === null || _b === void 0 ? void 0 : _b.clientMsgID) ===
+                                (message === null || message === void 0 ? void 0 : message.clientMsgID);
+                    })) === null || _a === void 0 ? void 0 : _a.map((msg) => msg === null || msg === void 0 ? void 0 : msg.clientMsgID);
+                    for (const relatedQuoteMessageId of relatedQuoteMessageIds || []) {
+                        const relatedQuoteMessageIdx = tmpList.findIndex((msg) => msg.clientMsgID === relatedQuoteMessageId);
+                        if (relatedQuoteMessageIdx >= 0) {
+                            tmpList[relatedQuoteMessageIdx] = Object.assign(Object.assign({}, tmpList[relatedQuoteMessageIdx]), { quoteElem: Object.assign(Object.assign({}, (_b = tmpList[relatedQuoteMessageIdx]) === null || _b === void 0 ? void 0 : _b.quoteElem), { quoteMessage: Object.assign(Object.assign({}, (_d = (_c = tmpList[relatedQuoteMessageIdx]) === null || _c === void 0 ? void 0 : _c.quoteElem) === null || _d === void 0 ? void 0 : _d.quoteMessage), { contentType: MessageType.RevokeMessage }) }) });
+                        }
+                    }
+                }
+                tmpList[idx] = Object.assign(Object.assign({}, tmpList[idx]), message);
+                return Object.assign(Object.assign({}, preState), { messageList: tmpList });
+            });
+        };
+        const removeOneMessage = (clientMsgID) => {
+            if (!canLoadRef.current)
+                return;
+            setLoadState((preState) => (Object.assign(Object.assign({}, preState), { messageList: preState.messageList.filter((msg) => msg.clientMsgID !== clientMsgID) })));
+        };
+        emitter.on("PUSH_NEW_MSG", pushNewMessage);
+        emitter.on("UPDATE_ONE_MSG", updateOneMessage);
+        emitter.on("REMOVE_ONE_MSG", removeOneMessage);
+        return () => {
+            emitter.off("PUSH_NEW_MSG", pushNewMessage);
+            emitter.off("UPDATE_ONE_MSG", updateOneMessage);
+            emitter.off("REMOVE_ONE_MSG", removeOneMessage);
+        };
+    }, []);
+    useEffect(() => {
+        if (!canLoad) {
+            setLoadState({
+                initLoading: true,
+                hasMoreOld: true,
+                hasMoreNew: false,
+                messageList: [],
+            });
+            return;
+        }
+        if (!conversationId)
+            return;
+        if (!isEmpty(searchClientMsgID)) {
+            searchMessages();
+        }
+        else {
+            getMoreOldMessages(false);
+        }
+        return () => {
+            setLoadState(() => ({
+                initLoading: true,
+                hasMoreOld: true,
+                hasMoreNew: false,
+                messageList: [],
+            }));
+        };
+    }, [conversationId, searchClientMsgID, canLoad, userID]);
+    return {
+        loadState,
+        latestLoadState,
+        moreOldLoading,
+        getMoreOldMessages,
+        moreNewLoading,
+        getMoreNewMessages,
+    };
+};
+export const pushNewMessage = (message) => emit("PUSH_NEW_MSG", message);
+export const updateOneMessage = (message) => emit("UPDATE_ONE_MSG", message);
+export const removeOneMessage = (clientMsgID) => emit("REMOVE_ONE_MSG", clientMsgID);
+export const getVisibleNeighbor = (allMessages, current, direction) => {
+    const currentIndex = allMessages.findIndex((m) => m.clientMsgID === current.clientMsgID);
+    if (currentIndex === -1)
+        return undefined;
+    const step = direction === "prev" ? 1 : -1;
+    let index = currentIndex + step;
+    while (index >= 0 && index < allMessages.length) {
+        const candidate = allMessages[index];
+        if (visibleTypeMessage.includes(candidate.contentType)) {
+            return candidate;
+        }
+        index += step;
+    }
+    return undefined;
+};
+const removeDuplicateMessages = (messages) => {
+    const seen = new Set();
+    return messages.filter((msg) => {
+        if (seen.has(msg.clientMsgID)) {
+            return false;
+        }
+        seen.add(msg.clientMsgID);
+        return true;
+    });
+};
+// Merges `base` with `incoming`, keeping each message at the position of its
+// first occurrence but letting `incoming` (the later/authoritative source,
+// e.g. a fresh server fetch) overwrite the content of any duplicate.
+const mergePreferringLatest = (base, incoming) => {
+    const byId = new Map();
+    const order = [];
+    for (const msg of [...base, ...incoming]) {
+        if (!byId.has(msg.clientMsgID)) {
+            order.push(msg.clientMsgID);
+        }
+        byId.set(msg.clientMsgID, msg);
+    }
+    return order.map((clientMsgID) => byId.get(clientMsgID));
+};

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

@@ -0,0 +1,30 @@
+import { RefObject } from "react";
+import { MessageItem } from "@openim/wasm-client-sdk";
+export declare const MESSAGE_LIST_BOTTOM_THRESHOLD = -5;
+export interface MessageListLoadState {
+    initLoading: boolean;
+    hasMoreOld: boolean;
+    hasMoreNew: boolean;
+    messageList: MessageItem[];
+}
+interface UseMessageListScrollParams {
+    conversationId?: string;
+    userId?: string;
+    loadState: MessageListLoadState;
+    latestLoadState: RefObject<MessageListLoadState | null>;
+    moreOldLoading: boolean;
+    moreNewLoading: boolean;
+    getMoreOldMessages: () => void | Promise<unknown>;
+    getMoreNewMessages: () => void | Promise<unknown>;
+}
+export declare const useMessageListScroll: ({ conversationId, userId, loadState, latestLoadState, moreOldLoading, moreNewLoading, getMoreOldMessages, getMoreNewMessages, }: UseMessageListScrollParams) => {
+    scrollRef: RefObject<HTMLDivElement>;
+    handleMarkConversationMessageAsRead: () => void;
+    loadMoreOldMessage: () => void;
+    handleInfiniteScroll: (e: React.UIEvent<HTMLDivElement>) => void;
+    scrollToBottom: () => void;
+    scrollToBottomIfAtBottom: () => void;
+    scrollToMessage: (clientMsgID: string) => void;
+};
+export {};
+//# sourceMappingURL=useMessageListScroll.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMessageListScroll.d.ts","sourceRoot":"","sources":["../../../../src/hooks/message/useMessageListScroll.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAkC,MAAM,OAAO,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAMtD,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAEhD,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,WAAW,EAAE,CAAC;CAC5B;AAED,UAAU,0BAA0B;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,oBAAoB,CAAC;IAChC,eAAe,EAAE,SAAS,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IACxD,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,kBAAkB,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAClD,kBAAkB,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACnD;AAED,eAAO,MAAM,oBAAoB,GAAI,iIASlC,0BAA0B;;;;8BA6DrB,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC;;;mCA0Ce,MAAM;CA6CzD,CAAC"}

package/dist/src/hooks/message/useMessageListScroll.js

@@ -0,0 +1,120 @@
+"use client";
+import { useCallback, useEffect, useRef } from "react";
+import { useDebounceFn } from "ahooks";
+import { isNumber } from "lodash";
+import { markConversationMessageAsRead } from "../../hooks/conversation/useConversation";
+import { MSG_ITEM_CONTENT_PREFIX, MSG_ITEM_PREFIX } from "../../constants";
+export const MESSAGE_LIST_BOTTOM_THRESHOLD = -5;
+export const useMessageListScroll = ({ conversationId, userId, loadState, latestLoadState, moreOldLoading, moreNewLoading, getMoreOldMessages, getMoreNewMessages, }) => {
+    const scrollRef = useRef(null);
+    const autoFillAttemptedRef = useRef(false);
+    useEffect(() => {
+        autoFillAttemptedRef.current = false;
+    }, [conversationId]);
+    const handleMarkConversationMessageAsRead = useCallback(() => {
+        var _a, _b, _c, _d;
+        const lastMessage = (_b = (_a = latestLoadState.current) === null || _a === void 0 ? void 0 : _a.messageList) === null || _b === void 0 ? void 0 : _b[0];
+        if (!conversationId ||
+            ((_c = latestLoadState.current) === null || _c === void 0 ? void 0 : _c.hasMoreNew) ||
+            moreNewLoading ||
+            (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.isRead) !== false ||
+            (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.sendID) === userId ||
+            !isNumber((_d = scrollRef.current) === null || _d === void 0 ? void 0 : _d.scrollTop) ||
+            scrollRef.current.scrollTop < MESSAGE_LIST_BOTTOM_THRESHOLD) {
+            return;
+        }
+        markConversationMessageAsRead(conversationId);
+    }, [conversationId, latestLoadState, moreNewLoading, userId]);
+    useEffect(() => {
+        if (!loadState.hasMoreNew &&
+            !loadState.initLoading &&
+            loadState.messageList.length > 0) {
+            handleMarkConversationMessageAsRead();
+        }
+    }, [
+        loadState.messageList.length,
+        loadState.hasMoreNew,
+        loadState.initLoading,
+        handleMarkConversationMessageAsRead,
+    ]);
+    const loadMoreOldMessage = useCallback(() => {
+        if (!loadState.hasMoreOld || moreOldLoading)
+            return;
+        const scrollEl = scrollRef.current;
+        if (scrollEl && scrollEl.scrollHeight <= scrollEl.clientHeight) {
+            if (autoFillAttemptedRef.current)
+                return;
+            autoFillAttemptedRef.current = true;
+        }
+        getMoreOldMessages();
+    }, [loadState.hasMoreOld, moreOldLoading, getMoreOldMessages]);
+    const { run: loadMoreNewMessage } = useDebounceFn(() => {
+        if (!loadState.hasMoreNew || moreNewLoading)
+            return;
+        getMoreNewMessages();
+    }, { wait: 200 });
+    const handleInfiniteScroll = useCallback((e) => {
+        const target = e.target;
+        if (target.scrollTop > MESSAGE_LIST_BOTTOM_THRESHOLD) {
+            handleMarkConversationMessageAsRead();
+            loadMoreNewMessage();
+        }
+    }, [handleMarkConversationMessageAsRead, loadMoreNewMessage]);
+    const scrollToBottom = useCallback(() => {
+        handleMarkConversationMessageAsRead();
+        setTimeout(() => {
+            var _a, _b, _c;
+            if (isNumber((_a = scrollRef.current) === null || _a === void 0 ? void 0 : _a.scrollTop) &&
+                scrollRef.current.scrollTop >= MESSAGE_LIST_BOTTOM_THRESHOLD) {
+                return;
+            }
+            (_b = scrollRef.current) === null || _b === void 0 ? void 0 : _b.scrollTo({
+                top: (_c = scrollRef.current) === null || _c === void 0 ? void 0 : _c.scrollHeight,
+                behavior: "smooth",
+            });
+        });
+    }, [handleMarkConversationMessageAsRead]);
+    const scrollToBottomIfAtBottom = useCallback(() => {
+        setTimeout(() => {
+            var _a;
+            if (!isNumber((_a = scrollRef.current) === null || _a === void 0 ? void 0 : _a.scrollTop) ||
+                scrollRef.current.scrollTop < MESSAGE_LIST_BOTTOM_THRESHOLD) {
+                return;
+            }
+            scrollRef.current.scrollTo({
+                top: scrollRef.current.scrollHeight,
+                behavior: "smooth",
+            });
+            handleMarkConversationMessageAsRead();
+        });
+    }, [handleMarkConversationMessageAsRead]);
+    const scrollToMessage = useCallback((clientMsgID) => {
+        setTimeout(() => {
+            const targetElement = document.getElementById(`${MSG_ITEM_PREFIX}${clientMsgID}`);
+            targetElement === null || targetElement === void 0 ? void 0 : targetElement.scrollIntoView({
+                behavior: "auto",
+                block: "center",
+            });
+            setTimeout(() => {
+                const targetContentElement = document.getElementById(`${MSG_ITEM_CONTENT_PREFIX}${clientMsgID}`);
+                targetContentElement === null || targetContentElement === void 0 ? void 0 : targetContentElement.classList.add("zoom-in-out-element", "border-blue-500", "border");
+                const onEnd = () => {
+                    targetContentElement === null || targetContentElement === void 0 ? void 0 : targetContentElement.classList.remove("zoom-in-out-element", "border-blue-500", "border");
+                    targetContentElement === null || targetContentElement === void 0 ? void 0 : targetContentElement.removeEventListener("animationend", onEnd);
+                };
+                targetContentElement === null || targetContentElement === void 0 ? void 0 : targetContentElement.addEventListener("animationend", onEnd, {
+                    once: true,
+                });
+            }, 500);
+        }, 200);
+    }, []);
+    return {
+        scrollRef,
+        handleMarkConversationMessageAsRead,
+        loadMoreOldMessage,
+        handleInfiniteScroll,
+        scrollToBottom,
+        scrollToBottomIfAtBottom,
+        scrollToMessage,
+    };
+};

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

@@ -0,0 +1,7 @@
+export declare const usePinMessage: () => {
+    pinMessage: (conversationID: string, clientMsgID: string) => Promise<void>;
+    unpinMessage: (conversationID: string, clientMsgID: string) => Promise<void>;
+    pinLoading: boolean;
+    unpinLoading: boolean;
+};
+//# sourceMappingURL=usePinMessage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePinMessage.d.ts","sourceRoot":"","sources":["../../../../src/hooks/message/usePinMessage.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,aAAa;;;;;CA6CzB,CAAC"}

package/dist/src/hooks/message/usePinMessage.js

@@ -0,0 +1,42 @@
+import { useRequest } from "ahooks";
+import { DChatSDK } from "../../constants/sdk";
+import useAuthStore from "../../store/auth";
+import { updateOneMessage } from "../../hooks/message/useMessage";
+import { fetchPinnedMessages } from "./usePinnedMessages";
+export const usePinMessage = () => {
+    const userID = useAuthStore((state) => state.userID);
+    const { runAsync: pinMessage, loading: pinLoading } = useRequest(async (conversationID, clientMsgID) => {
+        await DChatSDK.pinMsg({
+            conversationID,
+            clientMsgID,
+        });
+        updateOneMessage({
+            clientMsgID,
+            isPinned: true,
+            pinnedByUserID: userID,
+            pinnedTime: Date.now(),
+        });
+        await fetchPinnedMessages(conversationID);
+    }, {
+        manual: true,
+    });
+    const { runAsync: unpinMessage, loading: unpinLoading } = useRequest(async (conversationID, clientMsgID) => {
+        await DChatSDK.unpinMsg({
+            conversationID,
+            clientMsgID,
+        });
+        updateOneMessage({
+            clientMsgID,
+            isPinned: false,
+        });
+        await fetchPinnedMessages(conversationID);
+    }, {
+        manual: true,
+    });
+    return {
+        pinMessage,
+        unpinMessage,
+        pinLoading,
+        unpinLoading,
+    };
+};

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

@@ -0,0 +1,7 @@
+export declare const fetchPinnedMessages: (conversationID: string) => Promise<void>;
+export declare const usePinnedMessages: (conversationID: string) => {
+    pinnedMessageList: import("@openim/wasm-client-sdk").MessageItem[];
+    pinnedTotalCount: number;
+    pinnedRemainingCount: number;
+};
+//# sourceMappingURL=usePinnedMessages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePinnedMessages.d.ts","sourceRoot":"","sources":["../../../../src/hooks/message/usePinnedMessages.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB,GAAU,gBAAgB,MAAM,kBAoB/D,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,gBAAgB,MAAM;;;;CAqBvD,CAAC"}

package/dist/src/hooks/message/usePinnedMessages.js

@@ -0,0 +1,35 @@
+import { useEffect } from "react";
+import { DChatSDK } from "../../constants/sdk";
+import { PAGE_SIZE } from "../../constants";
+import useConversationStore from "../../store/conversation";
+export const fetchPinnedMessages = async (conversationID) => {
+    var _a, _b;
+    const { setPinnedMessageData } = useConversationStore.getState();
+    try {
+        const { data } = await DChatSDK.getPinnedMessageList({
+            conversationID,
+            offset: 0,
+            pageSize: PAGE_SIZE.small,
+        });
+        const sortedMessageList = [...(data.messageList || [])].sort((first, second) => (second.pinnedTime || 0) - (first.pinnedTime || 0));
+        setPinnedMessageData(sortedMessageList, data.totalCount || 0, (_a = data.remainingPinCount) !== null && _a !== void 0 ? _a : 0, (_b = data.isEnd) !== null && _b !== void 0 ? _b : true);
+    }
+    catch (error) {
+        console.error("fetchPinnedMessages failed", error);
+    }
+};
+export const usePinnedMessages = (conversationID) => {
+    const pinnedMessageList = useConversationStore((state) => state.pinnedMessageList);
+    const pinnedTotalCount = useConversationStore((state) => state.pinnedTotalCount);
+    const pinnedRemainingCount = useConversationStore((state) => state.pinnedRemainingCount);
+    useEffect(() => {
+        if (!conversationID)
+            return;
+        void fetchPinnedMessages(conversationID);
+    }, [conversationID]);
+    return {
+        pinnedMessageList,
+        pinnedTotalCount,
+        pinnedRemainingCount,
+    };
+};

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

@@ -0,0 +1,11 @@
+import { MessageItem } from "@openim/wasm-client-sdk";
+import { IPullSessionMessagesRequest } from "../../types/dto";
+interface UsePullSessionMessagesParams {
+    conversationID?: string;
+    userID?: string;
+    enabled?: boolean;
+}
+export declare const fetchPullSessionMessages: ({ conversationID, userID, applicationType, }: IPullSessionMessagesRequest) => Promise<MessageItem[]>;
+export declare const usePullSessionMessages: ({ conversationID, userID, enabled, }: UsePullSessionMessagesParams) => import("@tanstack/react-query").UseQueryResult<MessageItem[], Error>;
+export {};
+//# sourceMappingURL=usePullSessionMessages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePullSessionMessages.d.ts","sourceRoot":"","sources":["../../../../src/hooks/message/usePullSessionMessages.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAItD,OAAO,EAEL,2BAA2B,EAE5B,MAAM,aAAa,CAAC;AAOrB,UAAU,4BAA4B;IACpC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,wBAAwB,GAAU,8CAI5C,2BAA2B,KAAG,OAAO,CAAC,WAAW,EAAE,CAerD,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,sCAIpC,4BAA4B,yEAa9B,CAAC"}