Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🪟 perf: Virtualize Search Results and Stop the Per-Query Remount (#14352)

Danny Avilaaf7b2761eb2a
diff --git a/client/src/components/Chat/Messages/SearchMessage.tsx b/client/src/components/Chat/Messages/SearchMessage.tsx
index 955810b20b..e5daace2b7 100644
--- a/client/src/components/Chat/Messages/SearchMessage.tsx
+++ b/client/src/components/Chat/Messages/SearchMessage.tsx
@@ -1,6 +1,7 @@
-import { useMemo } from 'react';
+import { memo, useMemo } from 'react';
import { useAtomValue } from 'jotai';
import { useRecoilValue } from 'recoil';
+import type { TMessage } from 'librechat-data-provider';
import type { TMessageProps, TMessageIcon } from '~/common';
import MinimalHoverButtons from '~/components/Chat/Messages/MinimalHoverButtons';
import MessageTimestamp from '~/components/Chat/Messages/ui/MessageTimestamp';
@@ -39,7 +40,59 @@ const MessageBody = ({ message, messageLabel, fontSize }) => (
</div>
);
-export default function SearchMessage({ message }: Pick<TMessageProps, 'message'>) {
+function searchFilesEqual(prev?: TMessage['files'], next?: TMessage['files']) {
+ if (prev === next) {
+ return true;
+ }
+ const prevLen = prev?.length ?? 0;
+ const nextLen = next?.length ?? 0;
+ if (prevLen !== nextLen) {
+ return false;
+ }
+ return prev?.every((file, index) => file.file_id === next?.[index]?.file_id) ?? true;
+}
+
+/**
+ * Field-level comparator for `memo(SearchMessage)`. The virtualized `rowRenderer`
+ * closure and the file-remap `useMemo` in the Search route can hand a fresh
+ * `message` object with identical content on every parent render, so a shallow
+ * compare would defeat the memo — compare only the fields that drive the row.
+ */
+export function areSearchMessagePropsEqual(
+ prev: Pick<TMessageProps, 'message'>,
+ next: Pick<TMessageProps, 'message'>,
+): boolean {
+ const a = prev.message;
+ const b = next.message;
+ if (a === b) {
+ return true;
+ }
+ if (!a || !b) {
+ return a === b;
+ }
+ return (
+ a.messageId === b.messageId &&
+ a.text === b.text &&
+ a.content === b.content &&
+ a.createdAt === b.createdAt &&
+ /** Timestamp falls back to `clientTimestamp` when `createdAt` is absent. */
+ a.clientTimestamp === b.clientTimestamp &&
+ a.isCreatedByUser === b.isCreatedByUser &&
+ a.sender === b.sender &&
+ a.model === b.model &&
+ a.endpoint === b.endpoint &&
+ a.iconURL === b.iconURL &&
+ /** `SearchContent` renders an incomplete-response notice on `unfinished`. */
+ a.unfinished === b.unfinished &&
+ /** `SearchButtons` renders `title` and navigates by `conversationId`, so a
+ * rename/refetch that leaves the text and id intact must still re-render. */
+ a.title === b.title &&
+ a.conversationId === b.conversationId &&
+ searchFilesEqual(a.files, b.files)
+ );
+}
+
+function SearchMessage({ message }: Pick<TMessageProps, 'message'>) {
const fontSize = useAtomValue(fontSizeAtom);
const UsernameDisplay = useRecoilValue<boolean>(store.UsernameDisplay);
const { user } = useAuthContext();
@@ -86,3 +139,5 @@ export default function SearchMessage({ message }: Pick<TMessageProps, 'message'
</div>
);
}
+
+export default memo(SearchMessage, areSearchMessagePropsEqual);
diff --git a/client/src/components/Chat/Messages/__tests__/SearchMessage.comparator.spec.ts b/client/src/components/Chat/Messages/__tests__/SearchMessage.comparator.spec.ts
new file mode 100644
index 0000000000..107d1021a4
--- /dev/null
+++ b/client/src/components/Chat/Messages/__tests__/SearchMessage.comparator.spec.ts
@@ -0,0 +1,77 @@
+import type { TMessage } from 'librechat-data-provider';
+import { areSearchMessagePropsEqual } from '../SearchMessage';
+
+const msg = (overrides: Partial<TMessage> = {}): TMessage =>
+ ({
+ messageId: 'm1',
+ text: 'hello zephyrine',
+ content: undefined,
+ createdAt: '2026-07-20T00:00:00.000Z',
+ isCreatedByUser: false,
+ sender: 'GPT-3.5',
+ model: 'gpt-3.5-turbo',
+ endpoint: 'openAI',
+ iconURL: '',
+ files: undefined,
+ ...overrides,
+ }) as TMessage;
+
+describe('areSearchMessagePropsEqual', () => {
+ it('is true for the same reference', () => {
+ const m = msg();
+ expect(areSearchMessagePropsEqual({ message: m }, { message: m })).toBe(true);
+ });
+
+ it('is true for distinct objects with identical rendered fields (defeats a fresh useMemo remap)', () => {
+ expect(areSearchMessagePropsEqual({ message: msg() }, { message: msg() })).toBe(true);
+ });
+
+ it('is false when the text changes', () => {
+ expect(
+ areSearchMessagePropsEqual({ message: msg() }, { message: msg({ text: 'different' }) }),
+ ).toBe(false);
+ });
+
+ it('is false when the messageId changes', () => {
+ expect(
+ areSearchMessagePropsEqual({ message: msg() }, { message: msg({ messageId: 'm2' }) }),
+ ).toBe(false);
+ });
+
+ it('compares files by file_id, not object identity', () => {
+ const a = msg({ files: [{ file_id: 'f1' }] as TMessage['files'] });
+ const b = msg({ files: [{ file_id: 'f1' }] as TMessage['files'] });
+ expect(areSearchMessagePropsEqual({ message: a }, { message: b })).toBe(true);
+ const c = msg({ files: [{ file_id: 'f2' }] as TMessage['files'] });
+ expect(areSearchMessagePropsEqual({ message: a }, { message: c })).toBe(false);
+ });
+
+ it('is false when the conversation title changes (rename), even if text/id match', () => {
+ expect(
+ areSearchMessagePropsEqual({ message: msg() }, { message: msg({ title: 'Renamed' }) }),
+ ).toBe(false);
+ });
+
+ it('is false when the navigation target conversationId changes', () => {
+ expect(
+ areSearchMessagePropsEqual({ message: msg() }, { message: msg({ conversationId: 'c2' }) }),
+ ).toBe(false);
+ });
+
+ it('is false when the unfinished flag changes (incomplete-response notice)', () => {
+ expect(
+ areSearchMessagePropsEqual({ message: msg() }, { message: msg({ unfinished: true }) }),
+ ).toBe(false);
+ });
+
+ it('is false when only clientTimestamp changes (createdAt-less timestamp fallback)', () => {
+ const a = msg({ createdAt: undefined, clientTimestamp: '2026-07-20T00:00:00.000Z' });
+ const b = msg({ createdAt: undefined, clientTimestamp: '2026-07-20T01:00:00.000Z' });
+ expect(areSearchMessagePropsEqual({ message: a }, { message: b })).toBe(false);
+ });
+
+ it('is false when exactly one message is nullish', () => {
+ expect(areSearchMessagePropsEqual({ message: undefined }, { message: msg() })).toBe(false);
+ expect(areSearchMessagePropsEqual({ message: msg() }, { message: undefined })).toBe(false);
+ });
+});
diff --git a/client/src/routes/Search.tsx b/client/src/routes/Search.tsx
index b4db28c651..de6fe54894 100644
--- a/client/src/routes/Search.tsx
+++ b/client/src/routes/Search.tsx
@@ -1,19 +1,91 @@
-import { useEffect, useMemo } from 'react';
+import { memo, useCallback, useEffect, useMemo, useRef, type FC } from 'react';
+import { useAtomValue } from 'jotai';
+import throttle from 'lodash/throttle';
import { useRecoilValue } from 'recoil';
import { Spinner, useToastContext } from '@librechat/client';
-import MinimalMessagesWrapper from '~/components/Chat/Messages/MinimalMessages';
-import { useNavScrolling, useLocalize, useAuthContext } from '~/hooks';
+import { List, CellMeasurer, CellMeasurerCache } from 'react-virtualized';
+import type { Index, ListRowProps } from 'react-virtualized';
+import type { TMessage } from 'librechat-data-provider';
+import { useElementSize, useLocalize, useAuthContext } from '~/hooks';
import SearchMessage from '~/components/Chat/Messages/SearchMessage';
import { useMessagesInfiniteQuery } from '~/data-provider';
import { useFileMapContext } from '~/Providers';
+import { fontSizeAtom } from '~/store/fontSize';
+import { cn } from '~/utils';
import store from '~/store';
+type MeasuredCellParent = {
+ invalidateCellSizeAfterRender?: (cell: { columnIndex: number; rowIndex: number }) => void;
+ recomputeGridSize?: (cell: { columnIndex: number; rowIndex: number }) => void;
+};
+
+/** Fixed trailing spacer so the last result clears the bottom gradient/spinner
+ * overlay instead of sitting underneath it. */
+const FOOTER_HEIGHT = 64;
+
+/** Virtualized row wrapper that reports its measured height back to the cache.
+ * A ResizeObserver on the content re-measures when a row later grows or shrinks
+ * (a tool/code output expands, a late image loads), so the cached height that
+ * the List now lays out from never goes stale. */
+const MeasuredRow: FC<{
+ cache: CellMeasurerCache;
+ rowKey: string;
+ parent: MeasuredCellParent;
+ index: number;
+ style: React.CSSProperties;
+ onResize: (index: number) => void;
+ children: React.ReactNode;
+}> = memo(({ cache, rowKey, parent, index, style, onResize, children }) => {
+ const contentRef = useRef<HTMLDivElement | null>(null);
+
+ useEffect(() => {
+ const el = contentRef.current;
+ if (!el || typeof ResizeObserver === 'undefined') {
+ return;
+ }
+ const observer = new ResizeObserver((entries) => {
+ const height = entries[0]?.contentRect.height ?? 0;
+ /** Invalidate whenever the content differs from the height the List is
+ * laying out from — including the first callback, since a cached/fast
+ * image can already be taller than what CellMeasurer recorded at mount. */
+ if (height > 0 && Math.abs(height - cache.getHeight(index, 0)) > 1) {
+ onResize(index);
+ }
+ });
+ observer.observe(el);
+ return () => observer.disconnect();
+ }, [cache, index, onResize]);
+
+ return (
+ <CellMeasurer
+ cache={cache}
+ columnIndex={0}
+ key={rowKey}
+ parent={parent as ListRowProps['parent']}
+ rowIndex={index}
+ >
+ {({ registerChild }) => (
+ <div
+ ref={registerChild as React.LegacyRef<HTMLDivElement>}
+ style={style}
+ data-testid="search-result-row"
+ >
+ <div ref={contentRef}>{children}</div>
+ </div>
+ )}
+ </CellMeasurer>
+ );
+});
+
+MeasuredRow.displayName = 'SearchMeasuredRow';
+
export default function Search() {
const localize = useLocalize();
const fileMap = useFileMapContext();
const { showToast } = useToastContext();
const { isAuthenticated } = useAuthContext();
const search = useRecoilValue(store.search);
+ const fontSize = useAtomValue(fontSizeAtom);
const searchQuery = search.debouncedQuery;
const {
@@ -22,27 +94,21 @@ export default function Search() {
isError,
fetchNextPage,
isFetchingNextPage,
- hasNextPage: _hasNextPage,
+ hasNextPage,
+ isPreviousData,
} = useMessagesInfiniteQuery(
- {
- search: searchQuery || undefined,
- },
- {
- enabled: isAuthenticated && !!searchQuery,
- staleTime: 30000,
- cacheTime: 300000,
- },
+ { search: searchQuery || undefined },
+ { enabled: isAuthenticated && !!searchQuery, staleTime: 30000, cacheTime: 300000 },
);
- const { containerRef } = useNavScrolling({
- nextCursor: searchMessages?.pages[searchMessages.pages.length - 1]?.nextCursor,
- setShowLoading: () => ({}),
- fetchNextPage: fetchNextPage,
- isFetchingNext: isFetchingNextPage,
- });
+ /** Stale-results window: `isTyping` clears the moment the debounce publishes
+ * the new `debouncedQuery`, but `keepPreviousData` keeps the OLD pages mounted
+ * until the new request lands (`isPreviousData`). Both must gate the dimming
+ * and pagination, or the outgoing results look and page like the new search. */
+ const showingStale = search.isTyping || isPreviousData;
- const messages = useMemo(() => {
- const msgs =
+ const messages = useMemo(
+ () =>
searchMessages?.pages.flatMap((page) =>
page.messages.map((message) => {
if (!message.files || !fileMap) {
@@ -53,10 +119,148 @@ export default function Search() {
files: message.files.map((file) => fileMap[file.file_id ?? ''] ?? file),
};
}),
- ) || [];
+ ) ?? [],
+ [fileMap, searchMessages?.pages],
+ );
+
+ /** keyMapper reads a ref so the cache is created once and heights stay keyed
+ * to messageId (stable across pagination/reorders), not row index. */
+ const itemsRef = useRef<TMessage[]>(messages);
+ itemsRef.current = messages;
+
+ const listRef = useRef<List>(null);
+ const {
+ ref: listContainerRef,
+ width: listWidth,
+ height: listHeight,
+ } = useElementSize<HTMLDivElement>();
+
+ const cache = useMemo(
+ () =>
+ new CellMeasurerCache({
+ fixedWidth: true,
+ defaultHeight: 140,
+ keyMapper: (index) => itemsRef.current[index]?.messageId ?? `search-row-${index}`,
+ }),
+ [],
+ );
+
+ const recompute = useCallback(
+ (clear: boolean) => {
+ if (clear) {
+ cache.clearAll();
+ }
+ listRef.current?.recomputeRowHeights(0);
+ },
+ [cache],
+ );
+
+ /** A new query reseeds the list: prior results stay mounted (keepPreviousData)
+ * so the List keeps its old scrollTop — drop measured heights AND scroll back
+ * to the top, or the next search can open mid-list and hide the top matches. */
+ useEffect(() => {
+ const frameId = requestAnimationFrame(() => {
+ recompute(true);
+ listRef.current?.scrollToPosition(0);
+ });
+ return () => cancelAnimationFrame(frameId);
+ }, [searchQuery, recompute]);
+
+ /** A font-size change alters every row's height but keeps the user's place. */
+ useEffect(() => {
+ const frameId = requestAnimationFrame(() => recompute(true));
+ return () => cancelAnimationFrame(frameId);
+ }, [fontSize, recompute]);
+
+ /** Appending a page keeps existing measures; any other content change at the
+ * same row count (a file preview resolving, a refetch) can alter a row's
+ * rendered height, so drop the stale heights and re-measure. */
+ const prevCountRef = useRef(0);
+ useEffect(() => {
+ const grew = messages.length > prevCountRef.current;
+ prevCountRef.current = messages.length;
+ const frameId = requestAnimationFrame(() => recompute(!grew));
+ return () => cancelAnimationFrame(frameId);
+ }, [messages, recompute]);
+
+ /** fixedWidth cache keys heights by row, not width — re-measure on width change. */
+ const measuredWidthRef = useRef(0);
+ useEffect(() => {
+ if (listWidth === 0 || listWidth === measuredWidthRef.current) {
+ return;
+ }
+ measuredWidthRef.current = listWidth;
+ const frameId = requestAnimationFrame(() => recompute(true));
+ return () => cancelAnimationFrame(frameId);
+ }, [listWidth, recompute]);
+
+ /** Row-local size change (tool output expands, image loads): drop that row's
+ * cached height and recompute from it so the layout below stays correct. */
+ const invalidateRowHeight = useCallback(
+ (index: number) => {
+ cache.clear(index, 0);
+ listRef.current?.recomputeRowHeights(index);
+ },
+ [cache],
+ );
- return msgs.length === 0 ? null : msgs;
- }, [fileMap, searchMessages?.pages]);
+ /** `trailing: false` so a burst near the bottom can't queue a fetch that fires
+ * after the guard passed; cancel on query change so a pending page can't land
+ * on a new search. */
+ const throttledFetchNext = useMemo(
+ () => throttle(() => fetchNextPage(), 500, { leading: true, trailing: false }),
+ [fetchNextPage],
+ );
+ useEffect(() => () => throttledFetchNext.cancel(), [throttledFetchNext]);
+
+ const handleRowsRendered = useCallback(
+ ({ stopIndex }: { stopIndex: number }) => {
+ /** Don't page while the outgoing results are still mounted (typing, or the
+ * new query is still fetching and previous data is shown). */
+ if (showingStale || !hasNextPage || isFetchingNextPage) {
+ return;
+ }
+ if (stopIndex >= messages.length - 8) {
+ throttledFetchNext();
+ }
+ },
+ [showingStale, hasNextPage, isFetchingNextPage, messages.length, throttledFetchNext],
+ );
+
+ const rowRenderer = useCallback(
+ ({ index, key, parent, style }: ListRowProps) => {
+ const message = messages[index];
+ if (!message) {
+ /** Trailing spacer row (see FOOTER_HEIGHT). */
+ return (
+ <div key="search-footer" style={style} data-testid="search-footer" aria-hidden="true" />
+ );
+ }
+ /** react-virtualized's `key` is positional; key by messageId so React
+ * reconciles rows by message, not slot — otherwise a scroll reuses a row
+ * instance for a different result and re-parses/reruns its subtree. */
+ const rowKey = message.messageId ?? key;
+ return (
+ <MeasuredRow
+ key={rowKey}
+ cache={cache}
+ rowKey={rowKey}
+ parent={parent as MeasuredCellParent}
+ index={index}
+ style={style}
+ onResize={invalidateRowHeight}
+ >
+ <SearchMessage message={message} />
+ </MeasuredRow>
+ );
+ },
+ [cache, messages, invalidateRowHeight],
+ );
+
+ const getRowHeight = useCallback(
+ ({ index }: Index) => (index >= messages.length ? FOOTER_HEIGHT : cache.getHeight(index, 0)),
+ [cache, messages.length],
+ );
useEffect(() => {
if (isError && searchQuery) {
@@ -64,7 +268,7 @@ export default function Search() {
}
}, [isError, searchQuery, showToast]);
- const resultsCount = messages?.length ?? 0;
+ const resultsCount = messages.length;
const resultsAnnouncement = useMemo(() => {
if (resultsCount === 0) {
return localize('com_ui_nothing_found');
@@ -75,44 +279,70 @@ export default function Search() {
return localize('com_ui_results_found', { count: resultsCount });
}, [resultsCount, localize]);
- const isSearchLoading = search.isTyping || isLoading || isFetchingNextPage;
+ const loadingSpinner = (
+ <div className="absolute inset-0 flex items-center justify-center">
+ <Spinner className="text-text-primary" />
+ </div>
+ );
- if (isSearchLoading) {
- return (
- <div className="absolute inset-0 flex items-center justify-center">
- <Spinner className="text-text-primary" />
- </div>
- );
+ if (!searchQuery) {
+ /** A fresh query is typed but its debounce hasn't fired yet: show loading
+ * rather than a blank route during that first delay. */
+ return search.query && search.isTyping ? loadingSpinner : null;
}
- if (!searchQuery) {
- return null;
+ const hasResults = resultsCount > 0;
+
+ /** Spinner while there is nothing to show AND we're loading or the current
+ * results are stale — `showingStale` covers the case where the previous
+ * search was empty and `keepPreviousData` holds those empty pages during the
+ * new request, which would otherwise flash a false "nothing found". */
+ if ((isLoading || showingStale) && !hasResults) {
+ return loadingSpinner;
}
- return (
- <MinimalMessagesWrapper ref={containerRef} className="relative flex h-full pt-4">
- <div className="sr-only" role="alert" aria-atomic="true">
- {resultsAnnouncement}
- </div>
- {(messages && messages.length === 0) || messages == null ? (
+ if (!hasResults) {
+ return (
+ <>
+ <div className="sr-only" role="alert" aria-atomic="true">
+ {resultsAnnouncement}
+ </div>
<div className="absolute inset-0 flex items-center justify-center">
<div className="rounded-lg bg-white p-6 text-lg text-gray-500 dark:border-gray-800/50 dark:bg-gray-800 dark:text-gray-300">
{localize('com_ui_nothing_found')}
</div>
</div>
- ) : (
- <>
- {messages.map((msg) => (
- <SearchMessage key={msg.messageId} message={msg} />
- ))}
- {isFetchingNextPage && (
- <div className="flex justify-center py-4">
- <Spinner className="text-text-primary" />
- </div>
- )}
- </>
+ </>
+ );
+ }
+
+ return (
+ <div className="relative flex h-full w-full flex-col bg-white pt-4 dark:bg-gray-800">
+ <div className="sr-only" role="alert" aria-atomic="true">
+ {resultsAnnouncement}
+ </div>
+ <div ref={listContainerRef} className="min-h-0 flex-1">
+ <List
+ ref={listRef}
+ width={listWidth}
+ height={listHeight}
+ deferredMeasurementCache={cache}
+ rowCount={resultsCount + 1}
+ rowHeight={getRowHeight}
+ rowRenderer={rowRenderer}
+ onRowsRendered={handleRowsRendered}
+ overscanRowCount={10}
+ aria-label={localize('com_nav_search_placeholder')}
+ className={cn('outline-none', showingStale && 'opacity-70')}
+ style={{ outline: 'none' }}
+ />
+ </div>
+ {isFetchingNextPage && (
+ <div className="pointer-events-none absolute bottom-0 left-0 right-0 flex justify-center py-4">
+ <Spinner className="text-text-primary" />
+ </div>
)}
- <div className="absolute bottom-0 left-0 right-0 h-[5%] bg-gradient-to-t from-gray-50 to-transparent dark:from-gray-800" />
- </MinimalMessagesWrapper>
+ <div className="pointer-events-none absolute bottom-0 left-0 right-0 h-[5%] bg-gradient-to-t from-gray-50 to-transparent dark:from-gray-800" />
+ </div>
);
}
diff --git a/client/src/routes/__tests__/Search.spec.tsx b/client/src/routes/__tests__/Search.spec.tsx
new file mode 100644
index 0000000000..99a10f39c1
--- /dev/null
+++ b/client/src/routes/__tests__/Search.spec.tsx
@@ -0,0 +1,206 @@
+import React from 'react';
+import { useRecoilValue } from 'recoil';
+import { render, screen } from '@testing-library/react';
+import { useMessagesInfiniteQuery } from '~/data-provider';
+import Search from '../Search';
+
+/* react-virtualized measures nothing in jsdom; render every row flatly so the
+ list contents are exercised. */
+jest.mock('react-virtualized', () => ({
+ __esModule: true,
+ CellMeasurerCache: class {
+ getHeight() {
+ return 100;
+ }
+
+ clearAll() {}
+ },
+ CellMeasurer: ({
+ children,
+ }: {
+ children: (a: { registerChild: () => void }) => React.ReactNode;
+ }) => children({ registerChild: () => {} }),
+ List: ({
+ rowCount,
+ rowRenderer,
+ onRowsRendered,
+ }: {
+ rowCount: number;
+ rowRenderer: (p: {
+ index: number;
+ key: string;
+ parent: unknown;
+ style: object;
+ }) => React.ReactNode;
+ onRowsRendered?: (p: { startIndex: number; stopIndex: number }) => void;
+ }) => {
+ // expose the near-bottom trigger for the pagination test
+ (globalThis as Record<string, unknown>).__triggerRowsRendered = () =>
+ onRowsRendered?.({ startIndex: 0, stopIndex: rowCount - 1 });
+ return (
+ <div data-testid="virtual-list">
+ {Array.from({ length: rowCount }, (_, i) =>
+ rowRenderer({ index: i, key: String(i), parent: {}, style: {} }),
+ )}
+ </div>
+ );
+ },
+}));
+
+jest.mock('recoil', () => ({ useRecoilValue: jest.fn() }));
+jest.mock('~/data-provider', () => ({ useMessagesInfiniteQuery: jest.fn() }));
+jest.mock('~/Providers', () => ({ useFileMapContext: () => ({}) }));
+jest.mock('@librechat/client', () => ({
+ Spinner: () => <div data-testid="spinner" />,
+ useToastContext: () => ({ showToast: jest.fn() }),
+}));
+jest.mock('~/hooks', () => ({
+ useLocalize: () => (key: string) => key,
+ useAuthContext: () => ({ isAuthenticated: true }),
+ useElementSize: () => ({ ref: () => {}, width: 800, height: 600 }),
+}));
+jest.mock('~/store', () => ({ __esModule: true, default: { search: 'search-atom' } }));
+jest.mock('~/components/Chat/Messages/SearchMessage', () => ({
+ __esModule: true,
+ default: ({ message }: { message: { text: string } }) => (
+ <div className="search-row">{message.text}</div>
+ ),
+}));
+jest.mock('~/utils', () => ({ cn: (...a: unknown[]) => a.filter(Boolean).join(' ') }));
+jest.mock('jotai', () => ({ useAtomValue: () => 'text-base' }));
+jest.mock('~/store/fontSize', () => ({ fontSizeAtom: {} }));
+
+const mockUseRecoilValue = useRecoilValue as jest.Mock;
+const mockUseQuery = useMessagesInfiniteQuery as jest.Mock;
+
+const searchState = (over: Record<string, unknown> = {}) => ({
+ enabled: true,
+ query: 'zephyrine',
+ debouncedQuery: 'zephyrine',
+ isSearching: false,
+ isTyping: false,
+ ...over,
+});
+
+const queryResult = (over: Record<string, unknown> = {}) => ({
+ data: { pages: [{ messages: [{ messageId: 'm1', text: 'row one' }], nextCursor: null }] },
+ isLoading: false,
+ isError: false,
+ fetchNextPage: jest.fn(),
+ isFetchingNextPage: false,
+ hasNextPage: false,
+ isPreviousData: false,
+ ...over,
+});
+
+describe('Search route', () => {
+ beforeEach(() => jest.clearAllMocks());
+
+ it('renders result rows when data is present', () => {
+ mockUseRecoilValue.mockReturnValue(searchState());
+ mockUseQuery.mockReturnValue(queryResult());
+ render(<Search />);
+ expect(screen.getByText('row one')).toBeInTheDocument();
+ expect(screen.queryByTestId('spinner')).not.toBeInTheDocument();
+ });
+
+ it('keeps results mounted while typing (does NOT flash the full spinner)', () => {
+ mockUseRecoilValue.mockReturnValue(searchState({ isTyping: true }));
+ mockUseQuery.mockReturnValue(queryResult());
+ render(<Search />);
+ // The whole list must stay — this is the core regression fix.
+ expect(screen.getByText('row one')).toBeInTheDocument();
+ });
+
+ it('shows the full spinner only on initial load with no results', () => {
+ mockUseRecoilValue.mockReturnValue(searchState());
+ mockUseQuery.mockReturnValue(queryResult({ isLoading: true, data: undefined }));
+ render(<Search />);
+ expect(screen.getByTestId('spinner')).toBeInTheDocument();
+ expect(screen.queryByText('row one')).not.toBeInTheDocument();
+ });
+
+ it('shows nothing-found when the query returned no results', () => {
+ mockUseRecoilValue.mockReturnValue(searchState());
+ mockUseQuery.mockReturnValue(
+ queryResult({ data: { pages: [{ messages: [], nextCursor: null }] } }),
+ );
+ render(<Search />);
+ expect(screen.getAllByText('com_ui_nothing_found').length).toBeGreaterThan(0);
+ });
+
+ it('shows the spinner (not a false nothing-found) when stale empty data is held during a refetch', () => {
+ mockUseRecoilValue.mockReturnValue(searchState());
+ mockUseQuery.mockReturnValue(
+ queryResult({
+ data: { pages: [{ messages: [], nextCursor: null }] },
+ isPreviousData: true,
+ }),
+ );
+ render(<Search />);
+ expect(screen.getByTestId('spinner')).toBeInTheDocument();
+ expect(screen.queryByText('com_ui_nothing_found')).not.toBeInTheDocument();
+ });
+
+ it('renders nothing when there is no query and the user is idle', () => {
+ mockUseRecoilValue.mockReturnValue(searchState({ debouncedQuery: '' }));
+ mockUseQuery.mockReturnValue(queryResult({ data: undefined }));
+ const { container } = render(<Search />);
+ expect(container).toBeEmptyDOMElement();
+ });
+
+ it('shows the spinner during the initial debounce (query typed, not yet debounced)', () => {
+ mockUseRecoilValue.mockReturnValue(
+ searchState({ query: 'zephyrine', debouncedQuery: '', isTyping: true }),
+ );
+ mockUseQuery.mockReturnValue(queryResult({ data: undefined }));
+ render(<Search />);
+ expect(screen.getByTestId('spinner')).toBeInTheDocument();
+ });
+
+ it('announces empty results through a live region', () => {
+ mockUseRecoilValue.mockReturnValue(searchState());
+ mockUseQuery.mockReturnValue(
+ queryResult({ data: { pages: [{ messages: [], nextCursor: null }] } }),
+ );
+ render(<Search />);
+ expect(screen.getByRole('alert')).toHaveTextContent('com_ui_nothing_found');
+ });
+
+ it('fetches the next page when scrolled near the bottom', () => {
+ const fetchNextPage = jest.fn();
+ mockUseRecoilValue.mockReturnValue(searchState());
+ mockUseQuery.mockReturnValue(queryResult({ hasNextPage: true, fetchNextPage }));
+ render(<Search />);
+ (globalThis as unknown as Record<string, () => void>).__triggerRowsRendered();
+ expect(fetchNextPage).toHaveBeenCalled();
+ });
+
+ it('does NOT paginate the outgoing query while the user is still typing', () => {
+ const fetchNextPage = jest.fn();
+ mockUseRecoilValue.mockReturnValue(searchState({ isTyping: true }));
+ mockUseQuery.mockReturnValue(queryResult({ hasNextPage: true, fetchNextPage }));
+ render(<Search />);
+ (globalThis as unknown as Record<string, () => void>).__triggerRowsRendered();
+ expect(fetchNextPage).not.toHaveBeenCalled();
+ });
+
+ it('does NOT paginate while previous-query results are still mounted (refetch in flight)', () => {
+ const fetchNextPage = jest.fn();
+ mockUseRecoilValue.mockReturnValue(searchState());
+ mockUseQuery.mockReturnValue(
+ queryResult({ hasNextPage: true, isPreviousData: true, fetchNextPage }),
+ );
+ render(<Search />);
+ (globalThis as unknown as Record<string, () => void>).__triggerRowsRendered();
+ expect(fetchNextPage).not.toHaveBeenCalled();
+ });
+
+ it('renders a trailing spacer row so the last result clears the bottom overlay', () => {
+ mockUseRecoilValue.mockReturnValue(searchState());
+ mockUseQuery.mockReturnValue(queryResult());
+ render(<Search />);
+ expect(screen.getByText('row one')).toBeInTheDocument();
+ expect(screen.getByTestId('search-footer')).toBeInTheDocument();
+ });
+});