@droppii-org/chat-sdk 0.7.13 → 0.7.14

package/dist/hooks/group/useGroupMembers.js

@@ -1,41 +1,106 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { CbEvents } from "@droppii-org/wasm-client-sdk";
 import { DChatSDK } from "../../constants/sdk";
-const GROUP_MEMBER_LIST_OFFSET = 0;
-const GROUP_MEMBER_LIST_COUNT = 999;
-export const useGroupMembers = (groupID) => {
+const DEFAULT_PAGE_SIZE = 999;
+const appendNewMembers = (loaded, page) => {
+    const loadedIDs = new Set(loaded.map((member) => member.userID));
+    return [...loaded, ...page.filter((member) => !loadedIDs.has(member.userID))];
+};
+export const useGroupMembers = (groupID, { pageSize = DEFAULT_PAGE_SIZE } = {}) => {
     const [members, setMembers] = useState([]);
     const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const [hasMore, setHasMore] = useState(false);
     const [error, setError] = useState(undefined);
-    const fetchMembers = useCallback(async () => {
+    const membersRef = useRef(members);
+    membersRef.current = members;
+    // Bumped by every reload so a page that answers after it is dropped.
+    const loadIdRef = useRef(0);
+    const isLoadingMoreRef = useRef(false);
+    // Mirrors hasMore synchronously so no page is requested while a reload is in flight.
+    const hasMoreRef = useRef(false);
+    const updateHasMore = useCallback((value) => {
+        hasMoreRef.current = value;
+        setHasMore(value);
+    }, []);
+    const reload = useCallback(async (count, showSpinner) => {
+        var _a;
+        const loadId = ++loadIdRef.current;
+        updateHasMore(false);
         if (!groupID) {
             setMembers([]);
             setError(undefined);
+            setIsLoading(false);
             return;
         }
-        setIsLoading(true);
+        if (showSpinner)
+            setIsLoading(true);
         setError(undefined);
         try {
             const { data } = await DChatSDK.getGroupMemberList({
                 groupID,
                 filter: 0,
-                offset: GROUP_MEMBER_LIST_OFFSET,
-                count: GROUP_MEMBER_LIST_COUNT,
+                offset: 0,
+                count,
             });
+            if (loadId !== loadIdRef.current)
+                return;
             setMembers(data !== null && data !== void 0 ? data : []);
+            updateHasMore(((_a = data === null || data === void 0 ? void 0 : data.length) !== null && _a !== void 0 ? _a : 0) === count);
         }
         catch (err) {
+            if (loadId !== loadIdRef.current)
+                return;
             console.error("Error fetching group member list:", err);
             setMembers([]);
             setError("load_group_member_list_failed");
         }
         finally {
-            setIsLoading(false);
+            if (loadId === loadIdRef.current)
+                setIsLoading(false);
         }
-    }, [groupID]);
+    }, [groupID, updateHasMore]);
     useEffect(() => {
-        void fetchMembers();
-    }, [fetchMembers]);
+        setMembers([]);
+        void reload(pageSize, true);
+    }, [reload, pageSize]);
+    // Re-reads every row already shown, without a spinner, so a refetch never
+    // cuts a scrolled list short or jumps it back to the top.
+    const refetch = useCallback(() => reload(Math.max(pageSize, membersRef.current.length), false), [reload, pageSize]);
+    const loadMore = useCallback(async () => {
+        if (!groupID || !hasMoreRef.current || isLoadingMoreRef.current)
+            return;
+        const loadId = loadIdRef.current;
+        isLoadingMoreRef.current = true;
+        setIsLoadingMore(true);
+        try {
+            const { data } = await DChatSDK.getGroupMemberList({
+                groupID,
+                filter: 0,
+                offset: membersRef.current.length,
+                count: pageSize,
+            });
+            if (loadId !== loadIdRef.current)
+                return;
+            const page = data !== null && data !== void 0 ? data : [];
+            const loadedIDs = new Set(membersRef.current.map((member) => member.userID));
+            const hasNewRows = page.some((member) => !loadedIDs.has(member.userID));
+            setMembers((prev) => appendNewMembers(prev, page));
+            // A page of only known rows means core's order shifted; stop instead of re-requesting it.
+            updateHasMore(page.length === pageSize && hasNewRows);
+        }
+        catch (err) {
+            if (loadId !== loadIdRef.current)
+                return;
+            // Stop paging rather than retry on every scroll tick; reopening reloads.
+            console.error("Error fetching more group members:", err);
+            updateHasMore(false);
+        }
+        finally {
+            isLoadingMoreRef.current = false;
+            setIsLoadingMore(false);
+        }
+    }, [groupID, pageSize, updateHasMore]);
     useEffect(() => {
         if (!groupID)
             return;
@@ -44,7 +109,7 @@ export const useGroupMembers = (groupID) => {
                 setMembers((prev) => prev.filter((m) => m.userID !== data.userID));
             }
         };
-        const onMemberAdded = () => void fetchMembers();
+        const onMemberAdded = () => void refetch();
         // BE pushes the member's full updated record (roleLevel + the
         // permissions[] it reset to) whenever a role/permission change is
         // applied — e.g. setGroupMemberRoleLevel resets permissions to the new
@@ -65,7 +130,7 @@ export const useGroupMembers = (groupID) => {
             DChatSDK.off(CbEvents.OnGroupMemberAdded, onMemberAdded);
             DChatSDK.off(CbEvents.OnGroupMemberInfoChanged, onMemberInfoChanged);
         };
-    }, [groupID, fetchMembers]);
+    }, [groupID, refetch]);
     const patchMemberRole = useCallback((userID, roleLevel) => {
         setMembers((prev) => prev.map((member) => member.userID === userID ? Object.assign(Object.assign({}, member), { roleLevel }) : member));
     }, []);
@@ -76,8 +141,11 @@ export const useGroupMembers = (groupID) => {
     return {
         members,
         isLoading,
+        isLoadingMore,
+        hasMore,
         error,
-        refetch: fetchMembers,
+        refetch,
+        loadMore,
         patchMemberRole,
         patchMemberPermissions,
     };

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

@@ -1 +1 @@
-{"version":3,"file":"useSearchGroupMembers.d.ts","sourceRoot":"","sources":["../../../src/hooks/group/useSearchGroupMembers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAM/D,UAAU,2BAA2B;IACnC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,qBAAqB,GAChC,SAAS,MAAM,GAAG,SAAS,EAC3B,SAAS,MAAM,KACd,2BAkCF,CAAC"}
+{"version":3,"file":"useSearchGroupMembers.d.ts","sourceRoot":"","sources":["../../../src/hooks/group/useSearchGroupMembers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAM/D,UAAU,2BAA2B;IACnC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,qBAAqB,GAChC,SAAS,MAAM,GAAG,SAAS,EAC3B,SAAS,MAAM,KACd,2BAwCF,CAAC"}

package/dist/hooks/group/useSearchGroupMembers.js

@@ -1,13 +1,17 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { DChatSDK } from "../../constants/sdk";
 const SEARCH_GROUP_MEMBER_OFFSET = 0;
 const SEARCH_GROUP_MEMBER_COUNT = 999;
 export const useSearchGroupMembers = (groupID, keyword) => {
     const [results, setResults] = useState([]);
     const [isSearching, setIsSearching] = useState(false);
+    // Typing fires a search per keystroke; only the latest one may land.
+    const searchIdRef = useRef(0);
     const search = useCallback(async () => {
+        const searchId = ++searchIdRef.current;
         if (!groupID || !keyword.trim()) {
             setResults([]);
+            setIsSearching(false);
             return;
         }
         setIsSearching(true);
@@ -20,14 +24,19 @@ export const useSearchGroupMembers = (groupID, keyword) => {
                 offset: SEARCH_GROUP_MEMBER_OFFSET,
                 count: SEARCH_GROUP_MEMBER_COUNT,
             });
+            if (searchId !== searchIdRef.current)
+                return;
             setResults(data !== null && data !== void 0 ? data : []);
         }
         catch (err) {
+            if (searchId !== searchIdRef.current)
+                return;
             console.error("Error searching group members:", err);
             setResults([]);
         }
         finally {
-            setIsSearching(false);
+            if (searchId === searchIdRef.current)
+                setIsSearching(false);
         }
     }, [groupID, keyword]);
     useEffect(() => {

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

@@ -0,0 +1,317 @@
+import { MessageType } from "@droppii-org/wasm-client-sdk";
+import type { Pageable } from "../../types/dto";
+export declare const APP_MESSAGE_SEARCH_CONTENT_TYPES: MessageType[];
+interface UseAppMessageSearchParams {
+    queryKey: readonly unknown[];
+    /** Already trimmed; an empty term never searches. */
+    searchTerm: string;
+    /** One thread; omitted searches every thread the viewer has joined. */
+    conversationId?: string;
+    enabled: boolean;
+    staleTime?: number;
+}
+/** chat-service `POST /app/messages/search`, newest first, more pages on demand. */
+export declare const useAppMessageSearch: <TItem extends {
+    chatLog: {
+        clientMsgID: string;
+    };
+}>({ queryKey, searchTerm, conversationId, enabled, staleTime, }: UseAppMessageSearchParams) => {
+    results: TItem[];
+    data: import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchNextPageError: boolean;
+    isFetchingNextPage: boolean;
+    isFetchPreviousPageError: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>>;
+} | {
+    results: TItem[];
+    data: import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>>;
+} | {
+    results: TItem[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>>;
+} | {
+    results: TItem[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>>;
+} | {
+    results: TItem[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>>;
+} | {
+    results: TItem[];
+    data: import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    status: "success";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<{
+        data: TItem[];
+        pageable: Pageable;
+    }, unknown>>;
+};
+export {};
+//# sourceMappingURL=useAppMessageSearch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAppMessageSearch.d.ts","sourceRoot":"","sources":["../../../src/hooks/search/useAppMessageSearch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAK3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C,eAAO,MAAM,gCAAgC,eAK5C,CAAC;AAIF,UAAU,yBAAyB;IACjC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,oFAAoF;AACpF,eAAO,MAAM,mBAAmB,GAC9B,KAAK,SAAS;IAAE,OAAO,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,EAClD,+DAMC,yBAAyB;;;cAKqB,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;;;;;;;;;;;;;;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;;;cAA3B,KAAK,EAAE;kBAAY,QAAQ;;CAuC3E,CAAC"}

package/dist/hooks/search/useAppMessageSearch.js

@@ -0,0 +1,53 @@
+"use client";
+import { useMemo } from "react";
+import { useInfiniteQuery } from "@tanstack/react-query";
+import { MessageType } from "@droppii-org/wasm-client-sdk";
+import { PAGE_SIZE } from "../../constants";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import useAuthStore from "../../store/auth";
+// Text, link, quote and mention messages; media, stickers and system messages are not searchable.
+export const APP_MESSAGE_SEARCH_CONTENT_TYPES = [
+    MessageType.TextMessage,
+    MessageType.UrlTextMessage,
+    MessageType.QuoteMessage,
+    MessageType.AtTextMessage,
+];
+const APP_MESSAGE_SEARCH_PAGE_SIZE = PAGE_SIZE.medium;
+/** chat-service `POST /app/messages/search`, newest first, more pages on demand. */
+export const useAppMessageSearch = ({ queryKey, searchTerm, conversationId, enabled, staleTime, }) => {
+    const query = useInfiniteQuery({
+        initialPageParam: 1,
+        queryKey,
+        queryFn: async ({ pageParam }) => {
+            const res = await apiInstance.post(ENDPOINTS.chatService.searchAppMessages, Object.assign(Object.assign({}, (conversationId ? { conversationId } : {})), { searchTerm, contentTypes: APP_MESSAGE_SEARCH_CONTENT_TYPES, page: pageParam, pageSize: APP_MESSAGE_SEARCH_PAGE_SIZE, applicationType: useAuthStore.getState().applicationType }));
+            return res.data;
+        },
+        // totalElements is always 0, so a short page marks the end. A hit BE drops
+        // after paging (rare) can end the list one page early.
+        getNextPageParam: (lastPage, pages) => {
+            var _a, _b;
+            return ((_b = (_a = lastPage === null || lastPage === void 0 ? void 0 : lastPage.data) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) < APP_MESSAGE_SEARCH_PAGE_SIZE
+                ? undefined
+                : pages.length + 1;
+        },
+        enabled: enabled && searchTerm !== "",
+        retry: false,
+        refetchOnWindowFocus: false,
+        staleTime,
+    });
+    // New messages shift the offset pages, so a hit can come back on the next page too.
+    const results = useMemo(() => {
+        var _a, _b;
+        const seen = new Set();
+        return ((_b = (_a = query.data) === null || _a === void 0 ? void 0 : _a.pages.flatMap((page) => { var _a; return (_a = page === null || page === void 0 ? void 0 : page.data) !== null && _a !== void 0 ? _a : []; })) !== null && _b !== void 0 ? _b : []).filter((item) => {
+            var _a;
+            const id = (_a = item.chatLog) === null || _a === void 0 ? void 0 : _a.clientMsgID;
+            if (!id || seen.has(id))
+                return false;
+            seen.add(id);
+            return true;
+        });
+    }, [query.data]);
+    return Object.assign(Object.assign({}, query), { results });
+};