@droppii-org/chat-sdk 0.6.56 → 0.7.0

package/dist/hooks/canned-response/useSearchCannedAcrossScopes.js

@@ -0,0 +1,46 @@
+import { useMemo } from "react";
+import { useQueries } from "@tanstack/react-query";
+import { QUERY_KEYS } from "../../services/query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import { PAGE_SIZE } from "../../constants";
+import { mergeCannedResults, } from "../../components/canned-response/cannedScopes";
+// One request per scope with the existing search endpoint, merged in scope order.
+export const useSearchCannedAcrossScopes = (scopes, shortcut) => {
+    const enabled = shortcut.length > 0;
+    const combined = useQueries({
+        queries: scopes.map((scope) => ({
+            queryKey: [
+                QUERY_KEYS.GET_CANNED_RESPONSES,
+                "composer-search",
+                scope.key,
+                shortcut,
+            ],
+            enabled,
+            queryFn: async () => {
+                var _a, _b;
+                const res = await apiInstance.get(ENDPOINTS.chatService.getCannedResponses, {
+                    params: {
+                        visibilityScope: scope.visibilityScope,
+                        teamId: scope.teamId,
+                        shortcut,
+                        page: 1,
+                        pageSize: PAGE_SIZE.large,
+                    },
+                });
+                return (_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : [];
+            },
+        })),
+        combine: (results) => ({
+            data: results.map((r) => r.data),
+            isLoading: results.some((r) => r.isLoading),
+            isError: results.length > 0 && results.every((r) => r.isError),
+        }),
+    });
+    const rows = useMemo(() => mergeCannedResults(scopes, combined.data.map((data) => data !== null && data !== void 0 ? data : [])), [scopes, combined.data]);
+    return {
+        rows,
+        isLoading: enabled && combined.isLoading,
+        isError: enabled && combined.isError,
+    };
+};

package/dist/hooks/common/useCloseOnSidePanelOpen.d.ts

@@ -0,0 +1,3 @@
+/** CRM only: runs `onClose` when a side panel opens, so popovers never stack over it. */
+export declare const useCloseOnSidePanelOpen: (onClose: () => void) => void;
+//# sourceMappingURL=useCloseOnSidePanelOpen.d.ts.map

package/dist/hooks/common/useCloseOnSidePanelOpen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCloseOnSidePanelOpen.d.ts","sourceRoot":"","sources":["../../../src/hooks/common/useCloseOnSidePanelOpen.ts"],"names":[],"mappings":"AAKA,yFAAyF;AACzF,eAAO,MAAM,uBAAuB,GAAI,SAAS,MAAM,IAAI,SAS1D,CAAC"}

package/dist/hooks/common/useCloseOnSidePanelOpen.js

@@ -0,0 +1,15 @@
+"use client";
+import { useEffect, useRef } from "react";
+import useAuthStore from "../../store/auth";
+import useSidePanelStore from "../../store/sidePanel";
+/** CRM only: runs `onClose` when a side panel opens, so popovers never stack over it. */
+export const useCloseOnSidePanelOpen = (onClose) => {
+    const isCrm = useAuthStore((state) => state.isCrm);
+    const activePanel = useSidePanelStore((state) => state.activePanel);
+    const onCloseRef = useRef(onClose);
+    onCloseRef.current = onClose;
+    useEffect(() => {
+        if (isCrm && activePanel)
+            onCloseRef.current();
+    }, [isCrm, activePanel]);
+};

package/dist/hooks/common/useDeskShortcuts.d.ts

@@ -0,0 +1,11 @@
+export declare const DESK_ROW_SELECTOR = "[data-cp-name=\"DeskConversationRow\"]";
+export declare const DESK_SEARCH_SELECTOR = "[data-desk-search]";
+export declare const DESK_COMPOSER_SELECTOR = "[data-cp-name=\"ComposerEditor\"]";
+export declare const isTypingTarget: (target: EventTarget | null) => boolean;
+interface UseDeskShortcutsOptions {
+    onOpenHelp: () => void;
+}
+/** Desk keyboard shortcuts. Single-character keys never fire while typing. */
+export declare const useDeskShortcuts: ({ onOpenHelp }: UseDeskShortcutsOptions) => void;
+export {};
+//# sourceMappingURL=useDeskShortcuts.d.ts.map

package/dist/hooks/common/useDeskShortcuts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeskShortcuts.d.ts","sourceRoot":"","sources":["../../../src/hooks/common/useDeskShortcuts.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,iBAAiB,2CAAyC,CAAC;AACxE,eAAO,MAAM,oBAAoB,uBAAuB,CAAC;AACzD,eAAO,MAAM,sBAAsB,sCAAoC,CAAC;AAExE,eAAO,MAAM,cAAc,GAAI,QAAQ,WAAW,GAAG,IAAI,YAQxD,CAAC;AA2CF,UAAU,uBAAuB;IAC/B,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,GAAI,gBAAgB,uBAAuB,SAsCvE,CAAC"}

package/dist/hooks/common/useDeskShortcuts.js

@@ -0,0 +1,94 @@
+"use client";
+import { useEffect } from "react";
+import emitter from "../../utils/events";
+import useSidePanelStore from "../../store/sidePanel";
+import useEscapeLayersStore from "../../store/escapeLayers";
+import useShortcutPrefsStore from "../../store/shortcutPrefs";
+export const DESK_ROW_SELECTOR = '[data-cp-name="DeskConversationRow"]';
+export const DESK_SEARCH_SELECTOR = "[data-desk-search]";
+export const DESK_COMPOSER_SELECTOR = '[data-cp-name="ComposerEditor"]';
+export const isTypingTarget = (target) => {
+    if (!(target instanceof HTMLElement))
+        return false;
+    return (target.isContentEditable ||
+        target.closest('[contenteditable="true"]') !== null ||
+        ["INPUT", "TEXTAREA", "SELECT"].includes(target.tagName) ||
+        target.getAttribute("role") === "textbox");
+};
+const isModalOpen = () => Array.from(document.querySelectorAll(".ant-modal-wrap")).some((el) => el.style.display !== "none");
+/** Moves to the next/previous row in the order the list is rendered (filtered and loaded). */
+const moveListSelection = (step) => {
+    var _a, _b;
+    const rows = Array.from(document.querySelectorAll(DESK_ROW_SELECTOR));
+    if (!rows.length)
+        return;
+    const current = rows.findIndex((row) => row.getAttribute("aria-current") === "true");
+    const next = current === -1
+        ? step === 1
+            ? 0
+            : rows.length - 1
+        : Math.min(rows.length - 1, Math.max(0, current + step));
+    if (next === current)
+        return;
+    rows[next].click();
+    (_b = (_a = rows[next]).scrollIntoView) === null || _b === void 0 ? void 0 : _b.call(_a, { block: "nearest" });
+};
+const handleEscape = (event) => {
+    // Modals and drawers close themselves when they hold focus.
+    if (event.defaultPrevented || isModalOpen())
+        return;
+    if (useEscapeLayersStore.getState().closeTop())
+        return;
+    const sidePanel = useSidePanelStore.getState();
+    if (sidePanel.activePanel) {
+        sidePanel.closePanel();
+        return;
+    }
+    const active = document.activeElement;
+    if (active instanceof HTMLElement &&
+        active.closest(DESK_COMPOSER_SELECTOR)) {
+        active.blur();
+    }
+};
+/** Desk keyboard shortcuts. Single-character keys never fire while typing. */
+export const useDeskShortcuts = ({ onOpenHelp }) => {
+    useEffect(() => {
+        const onKeyDown = (event) => {
+            var _a;
+            if (event.key === "Escape") {
+                handleEscape(event);
+                return;
+            }
+            if (!useShortcutPrefsStore.getState().singleKeyEnabled)
+                return;
+            if (event.ctrlKey || event.metaKey || event.altKey || event.defaultPrevented)
+                return;
+            if (isTypingTarget(event.target) || isModalOpen())
+                return;
+            switch (event.key.toLowerCase()) {
+                case "j":
+                    moveListSelection(1);
+                    break;
+                case "k":
+                    moveListSelection(-1);
+                    break;
+                case "r":
+                    emitter.emit("COMPOSER_FOCUS_REQUEST", { mode: "reply" });
+                    break;
+                case "n":
+                    emitter.emit("COMPOSER_FOCUS_REQUEST", { mode: "internal" });
+                    break;
+                case "/":
+                    event.preventDefault();
+                    (_a = document.querySelector(DESK_SEARCH_SELECTOR)) === null || _a === void 0 ? void 0 : _a.focus();
+                    break;
+                case "?":
+                    event.preventDefault();
+                    onOpenHelp();
+                    break;
+            }
+        };
+        document.addEventListener("keydown", onKeyDown);
+        return () => document.removeEventListener("keydown", onKeyDown);
+    }, [onOpenHelp]);
+};

package/dist/hooks/common/useEscapeLayer.d.ts

@@ -0,0 +1,3 @@
+/** While `open`, Esc (from the desk shortcut hook) calls `close` before closing any panel. */
+export declare const useEscapeLayer: (open: boolean, close: () => void) => void;
+//# sourceMappingURL=useEscapeLayer.d.ts.map

package/dist/hooks/common/useEscapeLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEscapeLayer.d.ts","sourceRoot":"","sources":["../../../src/hooks/common/useEscapeLayer.ts"],"names":[],"mappings":"AAMA,8FAA8F;AAC9F,eAAO,MAAM,cAAc,GAAI,MAAM,OAAO,EAAE,OAAO,MAAM,IAAI,SAY9D,CAAC"}

package/dist/hooks/common/useEscapeLayer.js

@@ -0,0 +1,18 @@
+"use client";
+import { useEffect, useRef } from "react";
+import useEscapeLayersStore from "../../store/escapeLayers";
+let nextId = 1;
+/** While `open`, Esc (from the desk shortcut hook) calls `close` before closing any panel. */
+export const useEscapeLayer = (open, close) => {
+    const closeRef = useRef(close);
+    closeRef.current = close;
+    useEffect(() => {
+        if (!open)
+            return;
+        const id = nextId++;
+        useEscapeLayersStore
+            .getState()
+            .push({ id, close: () => closeRef.current() });
+        return () => useEscapeLayersStore.getState().remove(id);
+    }, [open]);
+};

package/dist/hooks/common/useMediaQuery.d.ts

@@ -0,0 +1,3 @@
+/** Subscribes to a CSS media query; returns `false` during SSR. */
+export declare const useMediaQuery: (query: string) => boolean;
+//# sourceMappingURL=useMediaQuery.d.ts.map

package/dist/hooks/common/useMediaQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMediaQuery.d.ts","sourceRoot":"","sources":["../../../src/hooks/common/useMediaQuery.ts"],"names":[],"mappings":"AAGA,mEAAmE;AACnE,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,OAW7C,CAAC"}

package/dist/hooks/common/useMediaQuery.js

@@ -0,0 +1,12 @@
+"use client";
+import { useCallback, useSyncExternalStore } from "react";
+/** Subscribes to a CSS media query; returns `false` during SSR. */
+export const useMediaQuery = (query) => {
+    const subscribe = useCallback((onChange) => {
+        const mql = window.matchMedia(query);
+        mql.addEventListener("change", onChange);
+        return () => mql.removeEventListener("change", onChange);
+    }, [query]);
+    const getSnapshot = () => window.matchMedia(query).matches;
+    return useSyncExternalStore(subscribe, getSnapshot, () => false);
+};

package/dist/hooks/common/useSidePanel.d.ts

@@ -0,0 +1,12 @@
+import { SidePanelKey } from "../../store/sidePanel";
+/**
+ * Open state of one side panel. In CRM the panels share a store so only one
+ * is open at a time; other apps keep an independent local state per panel.
+ */
+export declare const useSidePanel: (panel: SidePanelKey) => {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};
+//# sourceMappingURL=useSidePanel.d.ts.map

package/dist/hooks/common/useSidePanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSidePanel.d.ts","sourceRoot":"","sources":["../../../src/hooks/common/useSidePanel.ts"],"names":[],"mappings":"AAGA,OAA0B,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,YAAY;;;;;CAqB/C,CAAC"}

package/dist/hooks/common/useSidePanel.js

@@ -0,0 +1,32 @@
+"use client";
+import { useCallback, useState } from "react";
+import useAuthStore from "../../store/auth";
+import useSidePanelStore from "../../store/sidePanel";
+/**
+ * Open state of one side panel. In CRM the panels share a store so only one
+ * is open at a time; other apps keep an independent local state per panel.
+ */
+export const useSidePanel = (panel) => {
+    const isCrm = useAuthStore((state) => state.isCrm);
+    const isActive = useSidePanelStore((state) => state.activePanel === panel);
+    const [localOpen, setLocalOpen] = useState(false);
+    const open = useCallback(() => {
+        if (isCrm)
+            useSidePanelStore.getState().openPanel(panel);
+        else
+            setLocalOpen(true);
+    }, [isCrm, panel]);
+    const close = useCallback(() => {
+        if (isCrm)
+            useSidePanelStore.getState().closePanel(panel);
+        else
+            setLocalOpen(false);
+    }, [isCrm, panel]);
+    const toggle = useCallback(() => {
+        if (isCrm)
+            useSidePanelStore.getState().togglePanel(panel);
+        else
+            setLocalOpen((v) => !v);
+    }, [isCrm, panel]);
+    return { isOpen: isCrm ? isActive : localOpen, open, close, toggle };
+};

package/dist/hooks/group/useConversationGroups.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useConversationGroups.d.ts","sourceRoot":"","sources":["../../../src/hooks/group/useConversationGroups.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,gBAAgB,EAChB,eAAe,EAEhB,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAKnE,UAAU,2BAA2B;IACnC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,gBAAgB,CAAC;IAG/B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAMD,eAAO,MAAM,yBAAyB,GACpC,OAAO,sBAAsB,KAC5B,gBAyBD,CAAC;AAMH,eAAO,MAAM,6BAA6B,GACxC,QAAQ,sBAAsB,EAAE,kBAuBjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,yBAGnC,2BAAgC;;;;;;CAoElC,CAAC"}
+{"version":3,"file":"useConversationGroups.d.ts","sourceRoot":"","sources":["../../../src/hooks/group/useConversationGroups.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,gBAAgB,EAChB,eAAe,EAEhB,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAKnE,UAAU,2BAA2B;IACnC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,gBAAgB,CAAC;IAG/B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAMD,eAAO,MAAM,yBAAyB,GACpC,OAAO,sBAAsB,KAC5B,gBAyBD,CAAC;AAMH,eAAO,MAAM,6BAA6B,GACxC,QAAQ,sBAAsB,EAAE,kBAuBjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,yBAGnC,2BAAgC;;;;;;CAsElC,CAAC"}

package/dist/hooks/group/useConversationGroups.js

@@ -98,11 +98,14 @@ export const useConversationGroups = ({ enabled = true, pageSize = PAGE_SIZE.med
         // fallback built from the REST fields so the row never disappears.
         const allItems = data.pages.flatMap((page) => page.data);
         return allItems.map((group) => {
+            var _a, _b;
             const syncedConversation = conversationList === null || conversationList === void 0 ? void 0 : conversationList.find((conversation) => conversation.conversationID === group.conversationId);
             return {
                 groupId: group.groupId,
                 conversationId: group.conversationId,
                 conversation: syncedConversation !== null && syncedConversation !== void 0 ? syncedConversation : buildFallbackConversation(group),
+                visibility: (_a = group.visibility) !== null && _a !== void 0 ? _a : undefined,
+                memberCount: (_b = group.memberCount) !== null && _b !== void 0 ? _b : undefined,
             };
         });
     }, [data, conversationList]);

package/dist/hooks/message/useNewMessageAnnouncement.d.ts

@@ -0,0 +1,3 @@
+/** Text for an aria-live region: who wrote the newest incoming message, never its content. */
+export declare const useNewMessageAnnouncement: () => string;
+//# sourceMappingURL=useNewMessageAnnouncement.d.ts.map

package/dist/hooks/message/useNewMessageAnnouncement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNewMessageAnnouncement.d.ts","sourceRoot":"","sources":["../../../src/hooks/message/useNewMessageAnnouncement.ts"],"names":[],"mappings":"AAYA,8FAA8F;AAC9F,eAAO,MAAM,yBAAyB,cA2BrC,CAAC"}

package/dist/hooks/message/useNewMessageAnnouncement.js

@@ -0,0 +1,30 @@
+"use client";
+import { useEffect, useState } from "react";
+import { useTranslation } from "react-i18next";
+import emitter from "../../utils/events";
+import useAuthStore from "../../store/auth";
+import { isGroupNotificationMessageType, isSessionEventMessage, isSystemLogMessageType, } from "../../utils/messageLog";
+/** Text for an aria-live region: who wrote the newest incoming message, never its content. */
+export const useNewMessageAnnouncement = () => {
+    const { t } = useTranslation();
+    const userID = useAuthStore((state) => state.userID);
+    const [announcement, setAnnouncement] = useState("");
+    useEffect(() => {
+        let flip = false;
+        const onNewMessage = (message) => {
+            if (message.sendID === userID)
+                return;
+            if (isSystemLogMessageType(message.contentType) ||
+                isGroupNotificationMessageType(message.contentType) ||
+                isSessionEventMessage(message))
+                return;
+            flip = !flip;
+            // The trailing space flip makes a repeat from the same sender announce again.
+            setAnnouncement(t("new_message_from", { name: message.senderNickname || "" }) +
+                (flip ? "" : "​"));
+        };
+        emitter.on("PUSH_NEW_MSG", onNewMessage);
+        return () => emitter.off("PUSH_NEW_MSG", onNewMessage);
+    }, [userID, t]);
+    return announcement;
+};

package/dist/hooks/search/useSearchGroups.js

@@ -66,12 +66,13 @@ export const useSearchGroups = ({ searchTerm, enabled = true, pageSize = PAGE_SI
             return [];
         const allItems = data.pages.flatMap((page) => page.data);
         return allItems.map((group) => {
+            var _a;
             const syncedConversation = conversationList === null || conversationList === void 0 ? void 0 : conversationList.find((conversation) => conversation.conversationID === group.conversationId);
             return {
                 groupId: group.groupId,
                 conversationId: group.conversationId,
                 conversation: syncedConversation !== null && syncedConversation !== void 0 ? syncedConversation : buildSearchedGroupConversation(group),
-                visibility: group.visibility,
+                visibility: (_a = group.visibility) !== null && _a !== void 0 ? _a : undefined,
                 memberCount: group.memberCount,
             };
         });

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

@@ -7,8 +7,10 @@ interface UseSearchMessagePayload {
         untilEmptyPage?: boolean;
         scope?: SearchScope;
     };
+    /** False holds the request back, e.g. until the user has typed a term. */
+    enabled?: boolean;
 }
-export declare const useSearchMessage: ({ payload, options, }: UseSearchMessagePayload) => {
+export declare const useSearchMessage: ({ payload, options, enabled, }: UseSearchMessagePayload) => {
     error: Error;
     isError: true;
     isPending: false;

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;CAChF;AAED,eAAO,MAAM,gBAAgB,GAAI,uBAG9B,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0FzB,CAAC"}
+{"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"}

package/dist/hooks/search/useSearchMessage.js

@@ -19,7 +19,7 @@ import useAuthStore from "../../store/auth";
 import useConversationStore from "../../store/conversation";
 import { isGroupSession } from "../../utils/imCommon";
 import { PAGE_SIZE } from "../../constants";
-export const useSearchMessage = ({ payload, options, }) => {
+export const useSearchMessage = ({ payload, options, enabled = true, }) => {
     const isPdpPortal = (options === null || options === void 0 ? void 0 : options.scope) === "pdp-portal";
     const _a = useInfiniteQuery({
         initialPageParam: 1,
@@ -41,7 +41,7 @@ export const useSearchMessage = ({ payload, options, }) => {
             const pageSize = (options === null || options === void 0 ? void 0 : options.pageSize) || PAGE_SIZE.small;
             return dataLength < pageSize ? undefined : currentPage + 1;
         },
-        enabled: hasValidFilter(payload),
+        enabled: enabled && hasValidFilter(payload),
     }), { data, fetchNextPage, hasNextPage, isFetchingNextPage, isLoading } = _a, rest = __rest(_a, ["data", "fetchNextPage", "hasNextPage", "isFetchingNextPage", "isLoading"]);
     const { groupedData, dataFlatten } = useMemo(() => {
         var _a, _b;

package/dist/hooks/session/useBotSessionOwnerIdentity.d.ts

@@ -0,0 +1,12 @@
+import type { ConversationItem } from "@droppii-org/wasm-client-sdk";
+/** The customer behind a bot support thread as the agent sees it; `identity` is undefined for other threads. */
+export declare const useBotSessionOwnerIdentity: (conversationData: ConversationItem | null | undefined) => {
+    identity: {
+        displayName: string;
+        avatarUrl?: string;
+    } | null;
+    owner: import("../../types/dto").IGetUserSideInfoResponse | undefined;
+    /** A support thread whose customer is still loading; show a placeholder, not the bot group. */
+    isLoading: boolean;
+};
+//# sourceMappingURL=useBotSessionOwnerIdentity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBotSessionOwnerIdentity.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useBotSessionOwnerIdentity.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAUrE,gHAAgH;AAChH,eAAO,MAAM,0BAA0B,GACrC,kBAAkB,gBAAgB,GAAG,IAAI,GAAG,SAAS;;;;;;IAgBnD,+FAA+F;;CAGlG,CAAC"}

package/dist/hooks/session/useBotSessionOwnerIdentity.js

@@ -0,0 +1,22 @@
+"use client";
+import useAuthStore from "../../store/auth";
+import { useGetUserSideInfo } from "../../hooks/session/useGetUserSideInfo";
+import { PeerType } from "../../types/conversation";
+import { isSupportSessionAgentView, resolveBotSessionOwnerIdentity, resolveSupportSessionOwnerId, } from "../../utils/conversation";
+/** The customer behind a bot support thread as the agent sees it; `identity` is undefined for other threads. */
+export const useBotSessionOwnerIdentity = (conversationData) => {
+    var _a;
+    const selfUserID = useAuthStore((state) => state.userID);
+    // Same chat-service user record as the desk list's session owner.
+    const botSessionOwnerId = (conversationData === null || conversationData === void 0 ? void 0 : conversationData.peerType) === PeerType.BOT &&
+        isSupportSessionAgentView(conversationData, selfUserID)
+        ? resolveSupportSessionOwnerId(conversationData)
+        : "";
+    const { data: botSessionOwner, isPending } = useGetUserSideInfo((_a = conversationData === null || conversationData === void 0 ? void 0 : conversationData.conversationID) !== null && _a !== void 0 ? _a : "", botSessionOwnerId);
+    return {
+        identity: resolveBotSessionOwnerIdentity(conversationData, botSessionOwner, selfUserID),
+        owner: botSessionOwner,
+        /** A support thread whose customer is still loading; show a placeholder, not the bot group. */
+        isLoading: !!botSessionOwnerId && isPending,
+    };
+};

package/dist/hooks/session/useCloseSession.d.ts

@@ -1,3 +1,4 @@
 import { BaseResponse } from "../../types/dto";
+export declare const closeSessionRequest: (sessionId: string) => Promise<BaseResponse<boolean>>;
 export declare const useCloseSession: () => import("@tanstack/react-query").UseMutationResult<BaseResponse<boolean>, Error, string, unknown>;
 //# sourceMappingURL=useCloseSession.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useCloseSession.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useCloseSession.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,eAAO,MAAM,eAAe,wGAqB3B,CAAC"}
+{"version":3,"file":"useCloseSession.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useCloseSession.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,eAAO,MAAM,mBAAmB,GAAU,WAAW,MAAM,mCAW1D,CAAC;AAEF,eAAO,MAAM,eAAe,wGAU3B,CAAC"}

package/dist/hooks/session/useCloseSession.js

@@ -4,18 +4,19 @@ import { apiInstance } from "../../services/api";
 import { ENDPOINTS } from "../../services/routes";
 import useAuthStore from "../../store/auth";
 import { invalidateSessionQueries } from "../../utils/queryHelpers";
+export const closeSessionRequest = async (sessionId) => {
+    const res = await apiInstance.post(ENDPOINTS.chatService.closeSession(sessionId), null, {
+        params: {
+            applicationType: useAuthStore.getState().applicationType,
+        },
+    });
+    return res === null || res === void 0 ? void 0 : res.data;
+};
 export const useCloseSession = () => {
     const queryClient = useQueryClient();
     return useMutation({
         mutationKey: [QUERY_KEYS.CLOSE_SESSION],
-        mutationFn: async (sessionId) => {
-            const res = await apiInstance.post(ENDPOINTS.chatService.closeSession(sessionId), null, {
-                params: {
-                    applicationType: useAuthStore.getState().applicationType,
-                },
-            });
-            return res === null || res === void 0 ? void 0 : res.data;
-        },
+        mutationFn: closeSessionRequest,
         onSuccess: async () => {
             await invalidateSessionQueries(queryClient);
         },

package/dist/hooks/session/useEndSession.d.ts

@@ -0,0 +1,11 @@
+interface EndSessionTarget {
+    sessionId: string;
+    conversationId: string;
+}
+/**
+ * Ends a session after a short undo period: the close API is only called once
+ * the toast's "Hoàn tác" window has passed.
+ */
+export declare const useEndSession: () => ({ sessionId, conversationId }: EndSessionTarget) => void;
+export {};
+//# sourceMappingURL=useEndSession.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useEndSession.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useEndSession.tsx"],"names":[],"mappings":"AAUA,UAAU,gBAAgB;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,wCAKU,gBAAgB,SAgCnD,CAAC"}

package/dist/hooks/session/useEndSession.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback } from "react";
+import { message } from "antd";
+import { useQueryClient } from "@tanstack/react-query";
+import { useTranslation } from "react-i18next";
+import usePendingSessionCloseStore from "../../store/pendingSessionClose";
+import { invalidateSessionQueries } from "../../utils/queryHelpers";
+import EndSessionToast from "../../components/thread/EndSessionToast";
+import { StrokeIcon } from "../../components/icon/StrokeIcon";
+import { closeSessionRequest } from "./useCloseSession";
+/**
+ * Ends a session after a short undo period: the close API is only called once
+ * the toast's "Hoàn tác" window has passed.
+ */
+export const useEndSession = () => {
+    const queryClient = useQueryClient();
+    const { t } = useTranslation();
+    return useCallback(({ sessionId, conversationId }) => {
+        const toastKey = `end-session-${sessionId}`;
+        const scheduled = usePendingSessionCloseStore
+            .getState()
+            .schedule(sessionId, conversationId, async () => {
+            message.destroy(toastKey);
+            try {
+                await closeSessionRequest(sessionId);
+                await invalidateSessionQueries(queryClient);
+            }
+            catch (_a) {
+                message.error(t("close_session_failed"));
+            }
+        });
+        if (!scheduled)
+            return;
+        message.open({
+            key: toastKey,
+            type: "success",
+            icon: _jsx(StrokeIcon, { name: "check-circle", size: 18, className: "mr-2 text-success-900" }),
+            duration: 0,
+            content: (_jsx(EndSessionToast, { onUndo: () => {
+                    usePendingSessionCloseStore.getState().cancel(sessionId);
+                    message.destroy(toastKey);
+                } })),
+        });
+    }, [queryClient, t]);
+};

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

@@ -1 +1 @@
-{"version":3,"file":"useGetSession.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useGetSession.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,YAAY,EAIb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMhE,UAAU,kBAAkB;IAC1B,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,CAAC;CACH;AA6JD,eAAO,MAAM,aAAa,GAAI,sBAG3B,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFpB,CAAC"}
+{"version":3,"file":"useGetSession.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/useGetSession.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,YAAY,EAIb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMhE,UAAU,kBAAkB;IAC1B,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,CAAC;CACH;AAgLD,eAAO,MAAM,aAAa,GAAI,sBAG3B,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FpB,CAAC"}

package/dist/hooks/session/useGetSession.js

@@ -11,7 +11,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { useInfiniteQuery } from "@tanstack/react-query";
-import { useMemo } from "react";
+import { useEffect, useMemo } from "react";
 import { apiInstance } from "../../services/api";
 import { ENDPOINTS } from "../../services/routes";
 import { QUERY_KEYS } from "../../services/query";
@@ -106,11 +106,7 @@ const fetchSdkConversations = async (sessions) => {
     }
 };
 const findMissingSessionsFromSdk = (sessions, sdkConversations) => sessions.filter((session) => !sdkConversations.some((conversation) => conversation.conversationID === session.conversationId));
-const syncSessionConversationsToStore = async (sessions) => {
-    const currentList = useConversationStore.getState().conversationList;
-    const newSessions = sessions.filter((session) => !currentList.some((conversation) => conversation.conversationID === session.conversationId));
-    if (!newSessions.length)
-        return;
+const addSessionConversationsToStore = async (newSessions) => {
     const sdkConversations = await fetchSdkConversations(newSessions);
     const missingSessions = findMissingSessionsFromSdk(newSessions, sdkConversations);
     const conversationsToUpdate = [...sdkConversations];
@@ -132,6 +128,22 @@ const syncSessionConversationsToStore = async (sessions) => {
             .updateConversationList(conversationsToUpdate, "filter");
     }
 };
+// Conversation IDs being fetched, so several list hooks don't fetch the same rows twice.
+const syncingConversationIds = new Set();
+const syncSessionConversationsToStore = async (sessions) => {
+    const currentList = useConversationStore.getState().conversationList;
+    const newSessions = sessions.filter((session) => !syncingConversationIds.has(session.conversationId) &&
+        !currentList.some((conversation) => conversation.conversationID === session.conversationId));
+    if (!newSessions.length)
+        return;
+    newSessions.forEach((session) => syncingConversationIds.add(session.conversationId));
+    try {
+        await addSessionConversationsToStore(newSessions);
+    }
+    finally {
+        newSessions.forEach((session) => syncingConversationIds.delete(session.conversationId));
+    }
+};
 export const useGetSession = ({ filter, options = { pageSize: undefined, isEnabled: true }, }) => {
     var _a, _b;
     const pageSize = (_a = options === null || options === void 0 ? void 0 : options.pageSize) !== null && _a !== void 0 ? _a : PAGE_SIZE.medium;
@@ -183,6 +195,15 @@ export const useGetSession = ({ filter, options = { pageSize: undefined, isEnabl
         const allItems = data.pages.flatMap((page) => page.data);
         return allItems.length !== dataFlatten.length;
     }, [data, dataFlatten]);
+    // A full conversation-list reload (e.g. after sync finishes) replaces the
+    // store list and drops rows synced for this filter; fetch them again.
+    useEffect(() => {
+        if (!isSyncing || !data)
+            return;
+        void syncSessionConversationsToStore(data.pages.flatMap((page) => page.data)).catch((error) => {
+            console.error("syncSessionConversationsToStore", error);
+        });
+    }, [isSyncing, data]);
     return Object.assign({ data,
         fetchNextPage,
         hasNextPage,

package/dist/hooks/session/usePendingSessionClose.d.ts

@@ -0,0 +1,5 @@
+/** True while a session's close is waiting out its undo period. */
+export declare const useIsSessionClosePending: (sessionId?: string) => boolean;
+/** Sends any pending close for the conversation as soon as it is left or unmounted. */
+export declare const useFlushPendingCloseOnLeave: (conversationId?: string, enabled?: boolean) => void;
+//# sourceMappingURL=usePendingSessionClose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"usePendingSessionClose.d.ts","sourceRoot":"","sources":["../../../src/hooks/session/usePendingSessionClose.ts"],"names":[],"mappings":"AAGA,mEAAmE;AACnE,eAAO,MAAM,wBAAwB,GAAI,YAAY,MAAM,YAGxD,CAAC;AAEJ,uFAAuF;AACvF,eAAO,MAAM,2BAA2B,GACtC,iBAAiB,MAAM,EACvB,iBAAc,SAOf,CAAC"}