@droppii-org/chat-sdk 0.8.1 → 0.8.2

package/dist/hooks/message/useSendMessage.js

@@ -7,6 +7,7 @@ import { useQueryClient } from "@tanstack/react-query";
 import { useTranslation } from "react-i18next";
 import { pushNewMessage, removeOneMessage, updateOneMessage, } from "./useMessage";
 import { emit } from "../../utils/events";
+import { message as toast } from "antd";
 import useConversationStore from "../../store/conversation";
 import useAuthStore from "../../store/auth";
 import { apiInstance } from "../../services/api";
@@ -19,6 +20,8 @@ import { invalidateSessionQueries } from "../../utils/queryHelpers";
 import { resolveConversationBotId } from "../../utils/conversation";
 import { QUERY_KEYS } from "../../services/query";
 import { enqueue } from "../../utils/sendQueue";
+import { SDK_CALL_TIMEOUT_MS, SdkCallError, SdkTimeoutError, withSdkTimeout, } from "../../utils/withSdkTimeout";
+import { keepCurrentGroupMembersOnly } from "../../utils/mentionMembers";
 const messageFileStore = new Map();
 const MEDIA_CONTENT_TYPES = new Set([
     MessageType.PictureMessage,
@@ -27,106 +30,70 @@ const MEDIA_CONTENT_TYPES = new Set([
 ]);
 export const isMediaResendable = (message) => !MEDIA_CONTENT_TYPES.has(message.contentType) ||
     messageFileStore.has(message.clientMsgID);
-export const createTextMessage = async (text) => {
-    const textMessage = await DChatSDK.createTextMessage(text, new Date().getTime().toString())
-        .then(({ data }) => {
-        return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createTextMessage", errCode, errMsg);
-        return null;
+// Messages whose sendMessage call is still unsettled, including ones the UI already
+// gave up on after a timeout. Resending those would create a duplicate.
+// The value is when the UI gave up waiting (null while it still waits). A call stuck for
+// longer than the ceiling past that point is treated as lost so the user can resend.
+const PENDING_SEND_CEILING_MS = 120000;
+const pendingSends = new Map();
+const findCachedSession = (queryClient, sessionId) => {
+    var _a;
+    const cached = queryClient.getQueriesData({
+        queryKey: [QUERY_KEYS.GET_LIST_SESSION_BY_CONVERSATION],
     });
-    return textMessage;
+    for (const [, data] of cached) {
+        const found = (_a = data === null || data === void 0 ? void 0 : data.pages) === null || _a === void 0 ? void 0 : _a.flat().find((session) => session.id === sessionId);
+        if (found)
+            return found;
+    }
+    return undefined;
 };
-export const createImageMessageByFile = async (file) => {
-    const imageMessage = await DChatSDK.createImageMessageByFile(file, new Date().getTime().toString())
-        .then(({ data }) => {
+export const isSendPending = (clientMsgID) => {
+    if (!pendingSends.has(clientMsgID))
+        return false;
+    const gaveUpAt = pendingSends.get(clientMsgID);
+    return gaveUpAt == null || Date.now() - gaveUpAt < PENDING_SEND_CEILING_MS;
+};
+// Message builders fail loudly: a hung or rejected core call used to come back as
+// null, which looked like "nothing to send" and cleared the composer.
+const sendCall = async (label, call) => {
+    try {
+        const { data } = await withSdkTimeout(call, label);
         return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createImageMessageByFile", errCode, errMsg);
-        return null;
-    });
-    return imageMessage;
+    }
+    catch (error) {
+        console.error(label, error);
+        throw error;
+    }
+};
+export const createTextMessage = async (text) => {
+    return sendCall("createTextMessage", DChatSDK.createTextMessage(text, new Date().getTime().toString()));
+};
+export const createImageMessageByFile = async (file) => {
+    return sendCall("createImageMessageByFile", DChatSDK.createImageMessageByFile(file, new Date().getTime().toString()));
 };
 export const createMergerMessage = async (mergerMsgParams) => {
-    const mergerMessage = await DChatSDK.createMergerMessage(mergerMsgParams, new Date().getTime().toString())
-        .then(({ data }) => {
-        return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createMergerMessage", errCode, errMsg);
-        return null;
-    });
-    return mergerMessage;
+    return sendCall("createMergerMessage", DChatSDK.createMergerMessage(mergerMsgParams, new Date().getTime().toString()));
 };
 export const createVideoMessageByFile = async (file) => {
-    const videoMessage = await DChatSDK.createVideoMessageByFile(file, new Date().getTime().toString())
-        .then(({ data }) => {
-        return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createVideoMessageByFile", errCode, errMsg);
-        return null;
-    });
-    return videoMessage;
+    return sendCall("createVideoMessageByFile", DChatSDK.createVideoMessageByFile(file, new Date().getTime().toString()));
 };
 export const createFileMessageByFile = async (file) => {
-    const fileMessage = await DChatSDK.createFileMessageByFile(file, new Date().getTime().toString())
-        .then(({ data }) => {
-        return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createFileMessageByFile", errCode, errMsg);
-        return null;
-    });
-    return fileMessage;
+    return sendCall("createFileMessageByFile", DChatSDK.createFileMessageByFile(file, new Date().getTime().toString()));
 };
 // OpenIM SDK convention for "tag all members" in AtMsgParams.atUserIDList.
 export const AT_ALL_TAG = "AtAllTag";
 export const createAtTextMessage = async (params) => {
-    const atTextMessage = await DChatSDK.createTextAtMessage(params, new Date().getTime().toString())
-        .then(({ data }) => {
-        return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createTextAtMessage", errCode, errMsg);
-        return null;
-    });
-    return atTextMessage;
+    return sendCall("createTextAtMessage", DChatSDK.createTextAtMessage(params, new Date().getTime().toString()));
 };
 export const createUrlTextMessage = async (text, urls) => {
-    const textMessage = await DChatSDK.createUrlTextMessage(text, JSON.stringify(urls), new Date().getTime().toString())
-        .then(({ data }) => {
-        return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createUrlTextMessage", errCode, errMsg);
-        return null;
-    });
-    return textMessage;
+    return sendCall("createUrlTextMessage", DChatSDK.createUrlTextMessage(text, JSON.stringify(urls), new Date().getTime().toString()));
 };
 export const createStickerMessage = async (stickerUrl) => {
-    const stickerMessage = await DChatSDK.createStickerMessage(stickerUrl, uuidv4())
-        .then(({ data }) => {
-        return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createStickerMessage", errCode, errMsg);
-        return null;
-    });
-    return stickerMessage;
+    return sendCall("createStickerMessage", DChatSDK.createStickerMessage(stickerUrl, uuidv4()));
 };
 export const createCustomMessageByParams = async (params) => {
-    const customMessage = await DChatSDK.createCustomMessage(params, new Date().getTime().toString())
-        .then(({ data }) => {
-        return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createCustomMessage", errCode, errMsg);
-        return null;
-    });
-    return customMessage;
+    return sendCall("createCustomMessage", DChatSDK.createCustomMessage(params, new Date().getTime().toString()));
 };
 export const createCustomMessage = async (payload) => {
     return createCustomMessageByParams({
@@ -136,19 +103,11 @@ export const createCustomMessage = async (payload) => {
     });
 };
 export const createQuoteMessage = async (text, quotedMessage, urls) => {
-    const textMessage = await DChatSDK.createQuoteMessage({
+    return sendCall("createQuoteMessage", DChatSDK.createQuoteMessage({
         text,
         message: JSON.stringify(quotedMessage),
         urls,
-    })
-        .then(({ data }) => {
-        return data;
-    })
-        .catch(({ errCode, errMsg }) => {
-        console.error("createQuoteMessage", errCode, errMsg);
-        return null;
-    });
-    return textMessage;
+    }));
 };
 // Rebuilds a failed message under a new clientMsgID, re-attaching its stored files.
 const recreateFailedMessage = async (failedMessage) => {
@@ -249,6 +208,13 @@ const settleOrTimeout = (promise, ms) => new Promise((resolve) => {
         resolve();
     });
 });
+// Text goes out in moments; only a stored file can legitimately take longer.
+const sendDispatchTimeoutMs = (message) => {
+    var _a, _b;
+    const items = (_b = (_a = message.mergeElem) === null || _a === void 0 ? void 0 : _a.multiMessage) !== null && _b !== void 0 ? _b : [message];
+    const hasFiles = items.some((item) => storedFileBytes(item.clientMsgID) > 0);
+    return hasFiles ? sendHoldLimitMs(message) : SDK_CALL_TIMEOUT_MS;
+};
 let unsentCount = 0;
 const warnUnsent = (event) => {
     event.preventDefault();
@@ -274,7 +240,19 @@ export const useSendMessage = (options) => {
     const userId = useAuthStore((state) => state.userID);
     const { userID: recvID, groupID } = conversationData || {};
     const scrollEvent = (_a = options === null || options === void 0 ? void 0 : options.scrollEvent) !== null && _a !== void 0 ? _a : "CHAT_LIST_SCROLL_TO_BOTTOM";
-    const syncSessionAfterPublicMessage = useCallback(async (currentSession) => {
+    const syncSessionAfterPublicMessage = useCallback(async (sessionAtSend, isLateSuccess = false) => {
+        let currentSession = sessionAtSend;
+        if (isLateSuccess && (sessionAtSend === null || sessionAtSend === void 0 ? void 0 : sessionAtSend.id)) {
+            // Minutes may have passed since the send; the session can be closed or reassigned by now.
+            const latest = findCachedSession(queryClient, sessionAtSend.id);
+            if (latest &&
+                (latest.isClosed ||
+                    latest.status === SessionStatus.COMPLETED ||
+                    latest.supporterId !== sessionAtSend.supporterId)) {
+                return;
+            }
+            currentSession = latest !== null && latest !== void 0 ? latest : sessionAtSend;
+        }
         if (!(currentSession === null || currentSession === void 0 ? void 0 : currentSession.id)) {
             return;
         }
@@ -300,8 +278,8 @@ export const useSendMessage = (options) => {
             console.error("syncSessionAfterPublicMessage", error);
         }
     }, [queryClient]);
-    const dispatchMessage = useCallback(async (message) => {
-        var _a, _b, _c, _d, _e, _f;
+    const dispatchMessage = useCallback(async (message, onLateSent) => {
+        var _a, _b, _c, _d, _e;
         const plainText = ((_a = message === null || message === void 0 ? void 0 : message.textElem) === null || _a === void 0 ? void 0 : _a.content) ||
             ((_b = message === null || message === void 0 ? void 0 : message.quoteElem) === null || _b === void 0 ? void 0 : _b.text) ||
             ((_c = message === null || message === void 0 ? void 0 : message.urlTextElem) === null || _c === void 0 ? void 0 : _c.content) ||
@@ -317,7 +295,7 @@ export const useSendMessage = (options) => {
             icon: (conversationData === null || conversationData === void 0 ? void 0 : conversationData.faceURL) || "",
             conversationId: (conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID) || "",
         };
-        const { data: successMessage } = await DChatSDK.sendMessage({
+        const dispatched = DChatSDK.sendMessage({
             recvID: recvID || "",
             groupID: groupID || "",
             message,
@@ -339,8 +317,39 @@ export const useSendMessage = (options) => {
                 iOSBadgeCount: true,
             },
         });
-        updateOneMessage(Object.assign(Object.assign({}, successMessage), { ex: successMessage.ex || message.ex || "{}", isInternal: (_f = successMessage.isInternal) !== null && _f !== void 0 ? _f : message.isInternal }));
-        messageFileStore.delete(message.clientMsgID);
+        pendingSends.set(message.clientMsgID, null);
+        let isSettled = false;
+        const release = () => {
+            isSettled = true;
+            pendingSends.delete(message.clientMsgID);
+        };
+        dispatched.then(release, release);
+        const applySent = (successMessage) => {
+            var _a;
+            updateOneMessage(Object.assign(Object.assign({}, successMessage), { ex: successMessage.ex || message.ex || "{}", isInternal: (_a = successMessage.isInternal) !== null && _a !== void 0 ? _a : message.isInternal }));
+            messageFileStore.delete(message.clientMsgID);
+        };
+        try {
+            const { data } = await withSdkTimeout(dispatched, "sendMessage", sendDispatchTimeoutMs(message));
+            applySent(data);
+        }
+        catch (error) {
+            // The call may still land after we stop waiting: the bubble then ends Sent
+            // instead of staying Failed next to a message the server already has.
+            if (error instanceof SdkTimeoutError) {
+                // A call that settled while the timeout fired has nothing left to block a resend.
+                const gaveUpAt = Date.now();
+                if (!isSettled)
+                    pendingSends.set(message.clientMsgID, gaveUpAt);
+                dispatched.then(({ data }) => {
+                    applySent(data);
+                    // Past the ceiling the send is treated as lost, so it must not move the session.
+                    if (Date.now() - gaveUpAt < PENDING_SEND_CEILING_MS)
+                        onLateSent === null || onLateSent === void 0 ? void 0 : onLateSent();
+                }, () => { });
+            }
+            throw error;
+        }
     }, [
         groupID,
         recvID,
@@ -354,14 +363,23 @@ export const useSendMessage = (options) => {
     const sendQueueKey = (conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID) || "";
     // Bubbles show in call order and reach the server one at a time in that same order,
     // so a text sent right after a large video cannot overtake the video's upload.
-    const queueSend = useCallback((build, currentSession) => {
+    const queueSend = useCallback((build, currentSession, onBuilt) => {
         const shown = enqueue(`show:${sendQueueKey}`, async () => {
-            const messages = await build();
-            if (!(messages === null || messages === void 0 ? void 0 : messages.length))
-                return null;
-            messages.forEach((message) => pushNewMessage(message));
-            emit(scrollEvent);
-            return messages;
+            try {
+                const messages = await build();
+                if (!(messages === null || messages === void 0 ? void 0 : messages.length)) {
+                    onBuilt === null || onBuilt === void 0 ? void 0 : onBuilt(false);
+                    return null;
+                }
+                messages.forEach((message) => pushNewMessage(message));
+                emit(scrollEvent);
+                onBuilt === null || onBuilt === void 0 ? void 0 : onBuilt(true);
+                return messages;
+            }
+            catch (error) {
+                onBuilt === null || onBuilt === void 0 ? void 0 : onBuilt(false);
+                throw error;
+            }
         });
         const outcomes = [];
         let isSessionSynced = false;
@@ -372,11 +390,14 @@ export const useSendMessage = (options) => {
             });
             for (const message of messages !== null && messages !== void 0 ? messages : []) {
                 const holdLimitMs = sendHoldLimitMs(message);
-                const outcome = dispatchMessage(message).then(() => {
-                    if (!message.isInternal && !isSessionSynced) {
-                        isSessionSynced = true;
-                        void syncSessionAfterPublicMessage(currentSession);
-                    }
+                const syncSessionOnce = (isLateSuccess = false) => {
+                    if (message.isInternal || isSessionSynced)
+                        return;
+                    isSessionSynced = true;
+                    void syncSessionAfterPublicMessage(currentSession, isLateSuccess);
+                };
+                const outcome = dispatchMessage(message, () => syncSessionOnce(true)).then(() => {
+                    syncSessionOnce();
                     return true;
                 }, (error) => {
                     console.error("sendMessage", error);
@@ -391,21 +412,36 @@ export const useSendMessage = (options) => {
             .then(() => Promise.all(outcomes))
             .then((results) => results.length > 0 && results.every(Boolean)));
     }, [sendQueueKey, dispatchMessage, scrollEvent, syncSessionAfterPublicMessage]);
-    const resendMessage = useCallback((failedMessage) => queueSend(async () => {
-        const newPayload = await recreateFailedMessage(failedMessage);
-        if (!newPayload) {
-            updateOneMessage(Object.assign(Object.assign({}, failedMessage), { status: MessageStatus.Failed }));
-            return null;
+    const resendMessage = useCallback((failedMessage) => {
+        if (isSendPending(failedMessage.clientMsgID)) {
+            toast.warning(t("message_send_pending"));
+            return Promise.resolve(false);
         }
-        await DChatSDK.deleteMessageFromLocalStorage({
-            conversationID: sendQueueKey,
-            clientMsgID: failedMessage.clientMsgID,
+        return queueSend(async () => {
+            let newPayload;
+            try {
+                newPayload = await recreateFailedMessage(failedMessage);
+            }
+            catch (error) {
+                console.error("resendMessage", error);
+                toast.error(t("message_send_failed_no_retry"));
+                updateOneMessage(Object.assign(Object.assign({}, failedMessage), { status: MessageStatus.Failed }));
+                return null;
+            }
+            if (!newPayload) {
+                updateOneMessage(Object.assign(Object.assign({}, failedMessage), { status: MessageStatus.Failed }));
+                return null;
+            }
+            await DChatSDK.deleteMessageFromLocalStorage({
+                conversationID: sendQueueKey,
+                clientMsgID: failedMessage.clientMsgID,
+            });
+            removeOneMessage(failedMessage.clientMsgID);
+            return [
+                Object.assign(Object.assign({}, newPayload), { ex: failedMessage.ex, isInternal: failedMessage.isInternal }),
+            ];
         });
-        removeOneMessage(failedMessage.clientMsgID);
-        return [
-            Object.assign(Object.assign({}, newPayload), { ex: failedMessage.ex, isInternal: failedMessage.isInternal }),
-        ];
-    }), [queueSend, sendQueueKey]);
+    }, [queueSend, sendQueueKey, t]);
     const sendCustomMessage = useCallback(async (payload, sendOptions) => {
         if (!conversationData || (!recvID && !groupID))
             return false;
@@ -448,14 +484,31 @@ export const useSendMessage = (options) => {
         }
         return isSent;
     }, [conversationData, recvID, groupID, queueSend, queryClient]);
-    const sendMergeMessage = useCallback(async ({ richText, plainText, files = [], currentSession, isInternal, urlMetadata, flow, customMessage, mentions, }) => {
-        if (!conversationData || (!recvID && !groupID))
+    const sendMergeMessage = useCallback(async ({ richText, plainText, files = [], currentSession, isInternal, urlMetadata, flow, customMessage, mentions, onBuilt, }) => {
+        if (!conversationData || (!recvID && !groupID)) {
+            onBuilt === null || onBuilt === void 0 ? void 0 : onBuilt(false);
             return false;
+        }
         const hasText = !!plainText && plainText.trim() !== "";
         // Clear the reply bar now rather than when earlier queued sends finish building.
         const quoted = (quotedMessage === null || quotedMessage === void 0 ? void 0 : quotedMessage.clientMsgID) ? quotedMessage : undefined;
-        if (hasText && quotedMessage)
+        const isQuoteCleared = hasText && !!quotedMessage;
+        if (isQuoteCleared)
             setQuotedMessage(null);
+        const sentConversationId = conversationData.conversationID;
+        // A failed build puts the reply bar back, unless the user already moved on to
+        // another thread or picked a new quote.
+        const reportBuilt = (shown) => {
+            var _a;
+            if (!shown && isQuoteCleared) {
+                const state = useConversationStore.getState();
+                if (!state.quotedMessage &&
+                    ((_a = state.conversationData) === null || _a === void 0 ? void 0 : _a.conversationID) === sentConversationId) {
+                    setQuotedMessage(quotedMessage);
+                }
+            }
+            onBuilt === null || onBuilt === void 0 ? void 0 : onBuilt(shown);
+        };
         // Every bubble (image or album → videos → files → text) is built first and shown
         // together, the same order the mobile app uses.
         const buildMessages = async () => {
@@ -497,6 +550,9 @@ export const useSendMessage = (options) => {
                     imageMessages.push(imageMessage);
                 }
                 catch (err) {
+                    // A failed SDK call aborts the whole send so nothing is dropped silently.
+                    if (err instanceof SdkCallError)
+                        throw err;
                     console.error("Lỗi xử lý ảnh:", err);
                 }
             }
@@ -548,6 +604,9 @@ export const useSendMessage = (options) => {
                     messageList.push(videoMessage);
                 }
                 catch (err) {
+                    // A failed SDK call aborts the whole send so nothing is dropped silently.
+                    if (err instanceof SdkCallError)
+                        throw err;
                     console.error("Lỗi xử lý video:", err);
                 }
             }
@@ -575,22 +634,29 @@ export const useSendMessage = (options) => {
                     messageList.push(fileMessage);
                 }
                 catch (err) {
+                    // A failed SDK call aborts the whole send so nothing is dropped silently.
+                    if (err instanceof SdkCallError)
+                        throw err;
                     console.error("Lỗi xử lý tin nhắn:", err);
                 }
             }
-            const hasMentions = !!mentions && (mentions.atUserIDList.length > 0 || mentions.isAtAll);
+            const currentMentions = mentions
+                ? await keepCurrentGroupMembersOnly(groupID, mentions)
+                : undefined;
+            const hasMentions = !!currentMentions &&
+                (currentMentions.atUserIDList.length > 0 || currentMentions.isAtAll);
             if (hasText) {
                 const urls = extractLinkUrls(plainText);
                 let textMessage = null;
-                if (hasMentions && mentions) {
+                if (hasMentions && currentMentions) {
                     // OpenIM SDK convention: "tag all" is signaled by the sentinel
                     // "AtAllTag" inside atUserIDList, not a separate flag/param.
                     textMessage = await createAtTextMessage({
                         text: plainText,
-                        atUserIDList: mentions.isAtAll
-                            ? [AT_ALL_TAG, ...mentions.atUserIDList]
-                            : mentions.atUserIDList,
-                        atUsersInfo: mentions.atUsersInfo,
+                        atUserIDList: currentMentions.isAtAll
+                            ? [AT_ALL_TAG, ...currentMentions.atUserIDList]
+                            : currentMentions.atUserIDList,
+                        atUsersInfo: currentMentions.atUsersInfo,
                         message: quoted,
                         urls: urls || undefined,
                     });
@@ -625,13 +691,13 @@ export const useSendMessage = (options) => {
                     currentSession,
                     flow: isTextLikeMessage ? flow : undefined,
                     mentionOffsets: (message === null || message === void 0 ? void 0 : message.contentType) === MessageType.AtTextMessage
-                        ? mentions === null || mentions === void 0 ? void 0 : mentions.mentionOffsets
+                        ? currentMentions === null || currentMentions === void 0 ? void 0 : currentMentions.mentionOffsets
                         : undefined,
                 });
                 return Object.assign(Object.assign({}, message), { ex: JSON.stringify(extendMessageInfo) || "{}", isInternal });
             });
         };
-        return queueSend(buildMessages, currentSession);
+        return queueSend(buildMessages, currentSession, reportBuilt);
     }, [
         conversationData,
         recvID,

package/dist/hooks/search/useSearchMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSearchMessage.d.ts","sourceRoot":"","sources":["../../../src/hooks/search/useSearchMessage.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,oBAAoB,EAErB,MAAM,aAAa,CAAC;AAOrB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,UAAU,uBAAuB;IAC/B,OAAO,EAAE,IAAI,CACX,oBAAoB,EACpB,aAAa,GAAG,UAAU,GAAG,QAAQ,GAAG,YAAY,GAAG,KAAK,CAC7D,CAAC;IACF,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,WAAW,CAAA;KAAE,CAAC;IAC/E,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,gBAAgB,GAAI,gCAI9B,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0FzB,CAAC"}
+{"version":3,"file":"useSearchMessage.d.ts","sourceRoot":"","sources":["../../../src/hooks/search/useSearchMessage.ts"],"names":[],"mappings":"AAIA,OAAO,EAIL,oBAAoB,EAErB,MAAM,aAAa,CAAC;AASrB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,UAAU,uBAAuB;IAC/B,OAAO,EAAE,IAAI,CACX,oBAAoB,EACpB,aAAa,GAAG,UAAU,GAAG,QAAQ,GAAG,YAAY,GAAG,KAAK,CAC7D,CAAC;IACF,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,WAAW,CAAA;KAAE,CAAC;IAC/E,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,gBAAgB,GAAI,gCAI9B,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgHzB,CAAC"}

package/dist/hooks/search/useSearchMessage.js

@@ -13,6 +13,8 @@ import { useInfiniteQuery } from "@tanstack/react-query";
 import { QUERY_KEYS } from "../../services/query";
 import { apiInstance } from "../../services/api";
 import { ENDPOINTS } from "../../services/routes";
+import { ChatType } from "../../types/conversation";
+import { APP_MESSAGE_SEARCH_CONTENT_TYPES } from "./useAppMessageSearch";
 import { useMemo } from "react";
 import dayjs from "dayjs";
 import useAuthStore from "../../store/auth";
@@ -21,10 +23,24 @@ import { isGroupSession } from "../../utils/imCommon";
 import { PAGE_SIZE } from "../../constants";
 export const useSearchMessage = ({ payload, options, enabled = true, }) => {
     const isPdpPortal = (options === null || options === void 0 ? void 0 : options.scope) === "pdp-portal";
+    const isCrm = useAuthStore((state) => state.isCrm);
+    // Non-CRM hosts (Obefe) have no access to the CRM search endpoint.
+    const useAppEndpoints = !isCrm && !isPdpPortal;
+    // The app endpoints are scoped to the open thread, so cached pages must not cross threads.
+    const conversationId = useConversationStore((state) => { var _a; return (_a = state.conversationData) === null || _a === void 0 ? void 0 : _a.conversationID; });
     const _a = useInfiniteQuery({
         initialPageParam: 1,
-        queryKey: [QUERY_KEYS.SEARCH_MESSAGE, payload, options],
+        queryKey: [
+            QUERY_KEYS.SEARCH_MESSAGE,
+            payload,
+            options,
+            useAppEndpoints,
+            ...(useAppEndpoints ? [conversationId] : []),
+        ],
         queryFn: async ({ pageParam = 1 }) => {
+            if (useAppEndpoints) {
+                return fetchAppPage(payload, options === null || options === void 0 ? void 0 : options.pageSize, pageParam);
+            }
             const params = Object.assign(Object.assign({ pageSize: (options === null || options === void 0 ? void 0 : options.pageSize) || PAGE_SIZE.small }, payload), { page: pageParam, applicationType: useAuthStore.getState().applicationType });
             const res = await apiInstance.post(isPdpPortal
                 ? ENDPOINTS.chatService.searchPdpPortalMessages
@@ -42,6 +58,8 @@ export const useSearchMessage = ({ payload, options, enabled = true, }) => {
             return dataLength < pageSize ? undefined : currentPage + 1;
         },
         enabled: enabled && hasValidFilter(payload),
+        // A 4xx would otherwise retry and keep the spinner up.
+        retry: useAppEndpoints ? false : undefined,
     }), { data, fetchNextPage, hasNextPage, isFetchingNextPage, isLoading } = _a, rest = __rest(_a, ["data", "fetchNextPage", "hasNextPage", "isFetchingNextPage", "isLoading"]);
     const { groupedData, dataFlatten } = useMemo(() => {
         var _a, _b;
@@ -50,7 +68,11 @@ export const useSearchMessage = ({ payload, options, enabled = true, }) => {
                 groupedData: {},
                 dataFlatten: [],
             };
-        const rawItems = ((_b = (_a = data === null || data === void 0 ? void 0 : data.pages) === null || _a === void 0 ? void 0 : _a.flatMap) === null || _b === void 0 ? void 0 : _b.call(_a, (page) => page.data)) || [];
+        const pagedItems = ((_b = (_a = data === null || data === void 0 ? void 0 : data.pages) === null || _a === void 0 ? void 0 : _a.flatMap) === null || _b === void 0 ? void 0 : _b.call(_a, (page) => page.data)) || [];
+        // The app endpoints return revoked messages; the legacy UI can't render them.
+        const rawItems = useAppEndpoints
+            ? pagedItems.filter((item) => !item.isRevoked)
+            : pagedItems;
         // BE search isn't scoped to live membership — filter defensively
         // against conversationList, which leftGroupHandler keeps in sync.
         const joinedGroupIDs = new Set(useConversationStore
@@ -73,7 +95,7 @@ export const useSearchMessage = ({ payload, options, enabled = true, }) => {
             groupedData: mGroupeddata,
             dataFlatten: allItems,
         };
-    }, [data, isPdpPortal]);
+    }, [data, isPdpPortal, useAppEndpoints]);
     return Object.assign({ data,
         fetchNextPage,
         hasNextPage,
@@ -86,3 +108,35 @@ const hasValidFilter = (filter) => {
     const { searchTerm, recvID } = filter;
     return Boolean(searchTerm === null || searchTerm === void 0 ? void 0 : searchTerm.trim()) || Boolean(recvID === null || recvID === void 0 ? void 0 : recvID.trim());
 };
+/** App (non-CRM) endpoints: a term searches text messages, no term lists media by type. */
+const fetchAppPage = async (payload, pageSize, page) => {
+    var _a, _b, _c;
+    const size = pageSize || PAGE_SIZE.small;
+    const { applicationType } = useAuthStore.getState();
+    const conversationData = useConversationStore.getState().conversationData;
+    const term = (_a = payload.searchTerm) === null || _a === void 0 ? void 0 : _a.trim();
+    if (term) {
+        const res = await apiInstance.post(ENDPOINTS.chatService.searchAppMessages, Object.assign(Object.assign({}, ((conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID)
+            ? { conversationId: conversationData.conversationID }
+            : {})), { searchTerm: term, contentTypes: APP_MESSAGE_SEARCH_CONTENT_TYPES, page, pageSize: size, applicationType }));
+        return {
+            pageable: res.data.pageable,
+            data: ((_b = res.data.data) !== null && _b !== void 0 ? _b : []).map((item) => ({
+                chatLog: item.chatLog,
+                isRevoked: Boolean(item.chatLog.isRevoked),
+            })),
+        };
+    }
+    const params = {
+        recvID: (_c = payload.recvID) !== null && _c !== void 0 ? _c : "",
+        contentType: payload.contentType,
+        chatType: isGroupSession(conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationType)
+            ? ChatType.GROUP
+            : ChatType.SINGLE,
+        page,
+        pageSize: size,
+        applicationType,
+    };
+    const res = await apiInstance.post(ENDPOINTS.chatService.getMessageResources, params);
+    return res.data;
+};

package/dist/hooks/session/useConversationSessionState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useConversationSessionState.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useConversationSessionState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAI3D,UAAU,iCAAiC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,2BAA2B,GAAI,wCAIzC,iCAAiC;;;;;;CA6BnC,CAAC"}
+{"version":3,"file":"useConversationSessionState.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useConversationSessionState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAK3D,UAAU,iCAAiC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,2BAA2B,GAAI,wCAIzC,iCAAiC;;;;;;CA+BnC,CAAC"}

package/dist/hooks/session/useConversationSessionState.js

@@ -1,16 +1,19 @@
 "use client";
 import { useGetListSessionByConversation } from "./useGetListSessionByConversation";
 import { PeerType } from "../../types/conversation";
+import useAuthStore from "../../store/auth";
 export const useConversationSessionState = ({ conversationId, peerType, groupId, }) => {
     var _a;
     // Strict check, not isGroupConversation's loose conversationType fallback
     // — that wrongly disabled the session-list fetch and ran group-permission
     // checks against a support/bot thread's non-member-managed groupID.
     const isConfirmedGroup = peerType === PeerType.GROUP;
+    // The sessions API is CRM-only; other hosts (Obefe) get a 4xx from it.
+    const isCrm = useAuthStore((state) => state.isCrm);
     const currentGroupId = isConfirmedGroup ? groupId : undefined;
     const { data: conversationSessions, refetch: refetchConversationSessions, } = useGetListSessionByConversation({
         conversationId,
-        enabled: !isConfirmedGroup,
+        enabled: !isConfirmedGroup && isCrm,
     });
     const latestConversationSession = conversationSessions === null || conversationSessions === void 0 ? void 0 : conversationSessions[0];
     return {

package/dist/hooks/session/useSessionLatestPreview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSessionLatestPreview.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useSessionLatestPreview.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAyB,MAAM,8BAA8B,CAAC;AASvF,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAKD,MAAM,WAAW,yBAAyB;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,gBAAgB,CAAC;CACjC;AAkBD,eAAO,MAAM,uBAAuB,GAClC,UAAU,yBAAyB,EAAE;;;CA8EtC,CAAC"}
+{"version":3,"file":"useSessionLatestPreview.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useSessionLatestPreview.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAyB,MAAM,8BAA8B,CAAC;AAYvF,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAKD,MAAM,WAAW,yBAAyB;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,gBAAgB,CAAC;CACjC;AA6BD,eAAO,MAAM,uBAAuB,GAClC,UAAU,yBAAyB,EAAE;;;CA4FtC,CAAC"}