memos/web/src/components/PagedMemoList/PagedMemoList.tsx

323 lines
12 KiB
TypeScript

import { ArrowUpIcon, LoaderCircleIcon } from "lucide-react";
import { type ReactElement, type ReactNode, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
import { MentionResolutionProvider } from "@/components/MemoContent/MentionResolutionContext";
import { Button } from "@/components/ui/button";
import { useAuth } from "@/contexts/AuthContext";
import { useMemoFilterContext } from "@/contexts/MemoFilterContext";
import { useNewMemo } from "@/contexts/NewMemoContext";
import { useView } from "@/contexts/ViewContext";
import { useDelayedFlag } from "@/hooks/useDelayedFlag";
import { useInfiniteMemos } from "@/hooks/useMemoQueries";
import { hoistMemoToFront } from "@/hooks/useMemoSorting";
import { combineCELFilters } from "@/lib/cel-filter";
import { DEFAULT_LIST_MEMOS_PAGE_SIZE, LOADING_INDICATOR_DELAY_MS } from "@/lib/constants";
import { cn } from "@/lib/utils";
import { State } from "@/types/proto/api/v1/common_pb";
import type { Memo } from "@/types/proto/api/v1/memo_service_pb";
import { useTranslate } from "@/utils/i18n";
import ColumnGrid, { columnCountForWidth, GRID_GAP } from "../ColumnGrid";
import MemoFilters from "../MemoFilters";
import Placeholder from "../Placeholder";
import { estimateMemoCardHeight } from "./memoCardHeight";
// Memo identity for React keys and grid planning. The pages use it for their renderer keys too,
// so flow-list and grid identity can never drift apart. Deliberately name-only: content updates
// reconcile in place (updateTime is a protobuf Timestamp object, not usable in a template string).
export const getMemoKey = (memo: Memo) => memo.name;
// Columns never stretch past this, so 2 columns on a wide monitor stay readable and the
// grid centers in the leftover space instead of filling it.
const MAX_COLUMN_WIDTH = 420;
const Loader = () => (
<div className="w-full flex flex-row justify-center items-center py-8">
<LoaderCircleIcon className="h-6 w-6 animate-spin text-muted-foreground" />
</div>
);
interface Props {
renderer: (memo: Memo, options: { compact: boolean }) => ReactElement;
listSort?: (list: Memo[]) => Memo[];
state?: State;
orderBy?: string;
filter?: string;
contextFilter?: string;
pageSize?: number;
showCreator?: boolean;
enabled?: boolean;
/** Route-owned content rendered before the list and inside column one in grid mode. */
renderLeading?: (options: { useGrid: boolean }) => ReactNode;
}
function useAutoFetchWhenNotScrollable({
enabled,
hasNextPage,
isFetchingNextPage,
memoCount,
onFetchNext,
}: {
enabled: boolean;
hasNextPage: boolean | undefined;
isFetchingNextPage: boolean;
memoCount: number;
onFetchNext: () => Promise<unknown>;
}) {
const autoFetchTimeoutRef = useRef<number | null>(null);
const enabledRef = useRef(enabled);
enabledRef.current = enabled;
const isPageScrollable = useCallback(() => {
const documentHeight = Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
return documentHeight > window.innerHeight + 100;
}, []);
const checkAndFetchIfNeeded = useCallback(async () => {
if (autoFetchTimeoutRef.current) {
clearTimeout(autoFetchTimeoutRef.current);
}
await new Promise((resolve) => setTimeout(resolve, 200));
const shouldFetch = enabledRef.current && !isPageScrollable() && hasNextPage && !isFetchingNextPage && memoCount > 0;
if (shouldFetch) {
await onFetchNext();
if (enabledRef.current) {
autoFetchTimeoutRef.current = window.setTimeout(() => {
void checkAndFetchIfNeeded();
}, 500);
}
}
}, [enabled, hasNextPage, isFetchingNextPage, memoCount, isPageScrollable, onFetchNext]);
useEffect(() => {
if (enabled && !isFetchingNextPage && memoCount > 0) {
void checkAndFetchIfNeeded();
}
}, [enabled, memoCount, isFetchingNextPage, checkAndFetchIfNeeded]);
useEffect(() => {
if (!enabled && autoFetchTimeoutRef.current) {
clearTimeout(autoFetchTimeoutRef.current);
autoFetchTimeoutRef.current = null;
}
}, [enabled]);
useEffect(() => {
return () => {
if (autoFetchTimeoutRef.current) {
clearTimeout(autoFetchTimeoutRef.current);
}
};
}, []);
}
const PagedMemoList = (props: Props) => {
const t = useTranslate();
const { isUserSettingsInitialized } = useAuth();
const { filters } = useMemoFilterContext();
const { maxColumns, compactMode } = useView();
// maxColumns is a ceiling: 1 = single reading column, 0 = as many as fit. The single
// column renders in normal document flow; anything wider becomes the packed grid.
const multiColumn = maxColumns !== 1;
// Measure the available width: when it only fits one column anyway, render the flow
// layout rather than a degenerate one-column grid (capped tiles, composer-as-tile).
// Only the boolean is stored, so continuous resizes re-render nothing until the
// one-column threshold is actually crossed.
const layoutMeasureRef = useRef<HTMLDivElement>(null);
const [fitsGridWidth, setFitsGridWidth] = useState<boolean | undefined>(undefined);
useLayoutEffect(() => {
const el = layoutMeasureRef.current;
if (!el) return;
const apply = (nextWidth: number) => setFitsGridWidth(columnCountForWidth(nextWidth) >= 2);
apply(el.clientWidth);
if (typeof ResizeObserver === "undefined") return;
const observer = new ResizeObserver((entries) => apply(entries[0]?.contentRect.width ?? el.clientWidth));
observer.observe(el);
return () => observer.disconnect();
}, []);
const useGrid = multiColumn && (fitsGridWidth ?? true);
// Grid tiles are always bounded/compact; the narrow-width fallback behaves exactly like
// maxColumns = 1, so it respects the user's own compact setting. Centralized here so the
// pages don't each repeat the policy.
const effectiveCompact = compactMode || useGrid;
const { data, fetchNextPage, hasNextPage, isFetchingNextPage, isLoading } = useInfiniteMemos(
{
state: props.state || State.NORMAL,
orderBy: props.orderBy || "create_time desc",
filter: combineCELFilters(props.contextFilter, props.filter),
pageSize: props.pageSize || DEFAULT_LIST_MEMOS_PAGE_SIZE,
},
{ enabled: props.enabled ?? true },
);
// Tag settings decide whether sensitive memo content must be blurred. Keep that
// privacy boundary, but do not wait for unrelated memo views or instance settings.
const isDisplayPending = isLoading || !isUserSettingsInitialized;
const showLoader = useDelayedFlag(isDisplayPending, LOADING_INDICATOR_DELAY_MS);
// Flatten pages into a single array of memos
const memos = useMemo(() => data?.pages.flatMap((page) => page.memos) || [], [data]);
// Apply custom sorting if provided, otherwise use memos directly, then hoist
// a freshly created memo to the very top so it stays visible above pins.
const { newMemoName } = useNewMemo();
const sortedMemoList = useMemo(() => {
const sorted = props.listSort ? props.listSort(memos) : memos;
return hoistMemoToFront(sorted, newMemoName);
}, [memos, props.listSort, newMemoName]);
// Auto-fetch hook: fetches more content when page isn't scrollable
useAutoFetchWhenNotScrollable({
enabled: !isDisplayPending,
hasNextPage,
isFetchingNextPage,
memoCount: sortedMemoList.length,
onFetchNext: fetchNextPage,
});
// Infinite scroll: fetch more when user scrolls near bottom
useEffect(() => {
if (isDisplayPending || !hasNextPage) return;
const handleScroll = () => {
const nearBottom = window.innerHeight + window.scrollY >= document.body.offsetHeight - 300;
if (nearBottom && !isFetchingNextPage) {
fetchNextPage();
}
};
window.addEventListener("scroll", handleScroll);
return () => window.removeEventListener("scroll", handleScroll);
}, [isDisplayPending, hasNextPage, isFetchingNextPage, fetchNextPage]);
const leadingContent = props.renderLeading?.({ useGrid });
// A freshly created memo is hoisted to the front; pin it to the top of column one so it
// appears right under the composer instead of dropping into a random (shortest) column.
const displayMemoList = isDisplayPending ? [] : sortedMemoList;
const firstMemo = displayMemoList[0];
const priorityKey = newMemoName && firstMemo?.name === newMemoName ? getMemoKey(firstMemo) : undefined;
// Stable reference so MentionResolutionProvider's memo (keyed on the array) actually holds.
const contents = useMemo(() => displayMemoList.map((memo) => memo.content), [displayMemoList]);
const userNames = useMemo(
() =>
Array.from(
new Set(
displayMemoList.flatMap((memo) => [
...(props.showCreator ? [memo.creator] : []),
...(memo.reactions ?? []).map((reaction) => reaction.creator),
]),
),
),
[props.showCreator, displayMemoList],
);
const emptyPlaceholder =
!isDisplayPending && !isFetchingNextPage && !hasNextPage && displayMemoList.length === 0 ? (
<Placeholder variant="empty" message={t("message.no-data")} className="w-full" />
) : null;
const initialLoader = isDisplayPending && showLoader ? <Loader /> : null;
// Column one is the action column: the composer and any active filters head it, and the
// empty state follows them. The newest memo also lands directly beneath them (priorityKey
// above). Every vertical seam inside the stack uses GRID_GAP so y-spacing matches the
// grid's x-spacing exactly.
const hasFilters = filters.length > 0;
const gridLeading =
leadingContent || hasFilters || initialLoader || emptyPlaceholder ? (
<div className="flex w-full flex-col" style={{ gap: GRID_GAP }}>
{leadingContent}
<MemoFilters />
{initialLoader}
{emptyPlaceholder}
</div>
) : undefined;
// Pagination controls are identical across both layouts.
const footer = (
<>
{isFetchingNextPage && <Loader />}
{!isFetchingNextPage && (hasNextPage || displayMemoList.length > 0) && (
<div className="w-full opacity-70 flex flex-row justify-center items-center my-4">
<BackToTop />
</div>
)}
</>
);
const children = (
<MentionResolutionProvider contents={contents} userNames={userNames}>
<div ref={layoutMeasureRef} className="w-full">
<div className={cn("flex flex-col justify-start w-full mx-auto", useGrid ? "max-w-none" : "max-w-2xl")}>
{useGrid ? (
<>
<ColumnGrid
items={displayMemoList}
getKey={getMemoKey}
renderItem={(memo) => props.renderer(memo, { compact: effectiveCompact })}
estimateHeight={estimateMemoCardHeight}
leading={gridLeading}
priorityKey={priorityKey}
maxColumns={maxColumns}
maxColumnWidth={MAX_COLUMN_WIDTH}
/>
{!isDisplayPending && footer}
</>
) : (
<>
{leadingContent}
<MemoFilters className="mb-2" />
{initialLoader}
{displayMemoList.map((memo) => props.renderer(memo, { compact: effectiveCompact }))}
{emptyPlaceholder}
{!isDisplayPending && footer}
</>
)}
</div>
</div>
</MentionResolutionProvider>
);
return children;
};
const BackToTop = () => {
const t = useTranslate();
const [isVisible, setIsVisible] = useState(false);
useEffect(() => {
const handleScroll = () => {
const shouldShow = window.scrollY > 400;
setIsVisible(shouldShow);
};
window.addEventListener("scroll", handleScroll);
return () => window.removeEventListener("scroll", handleScroll);
}, []);
const scrollToTop = () => {
window.scrollTo({
top: 0,
behavior: "smooth",
});
};
// Don't render if not visible
if (!isVisible) {
return null;
}
return (
<Button variant="ghost" onClick={scrollToTop}>
{t("router.back-to-top")}
<ArrowUpIcon className="ml-1 w-4 h-auto" />
</Button>
);
};
export default PagedMemoList;