Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(web): unify conversation bottom ownership (#828)

Genercc6a197c3970
diff --git a/src/web/src/app/c/me/[dmId]/page.test.ts b/src/web/src/app/c/me/[dmId]/page.test.ts
index 887121df5..d8e8cb564 100644
--- a/src/web/src/app/c/me/[dmId]/page.test.ts
+++ b/src/web/src/app/c/me/[dmId]/page.test.ts
@@ -13,6 +13,16 @@ describe("DM page loading ownership", () => {
expect(source).toContain("if (loadingOwnership.fullFramePending)")
expect(source).toContain("<DmHeader\n")
expect(source).toContain("<Composer\n")
+ expect(source).toContain("<ConversationFooterShell\n")
+ expect(source).toContain("<ConversationFooterSlotProvider>")
+ expect(source).toContain('data-slot="community-conversation-surface"')
+ expect(source).toContain("data-channel-id={dmId}")
+ expect(source).not.toContain("composerOverlap")
+ expect(source).not.toContain("onOverlapChange")
+ expect(source).toContain("typingUsers={typingUsers.map((id) => typingNames[id] ?? resolveUserName(id))}")
+ const messageListProps = source.split(" <MessageList\n")[1]?.split(" />")[0]
+ expect(messageListProps).not.toContain("typingUsers")
+ expect(source).not.toContain('data-onboarding-name={dm.name} className="shrink-0"')
expect(source).toContain("loading={loadingOwnership.messageBodyLoading}")
expect(source).not.toContain("<ComposerSkeleton")
expect(source).not.toContain("<DmHeaderSkeleton")
diff --git a/src/web/src/app/c/me/[dmId]/page.tsx b/src/web/src/app/c/me/[dmId]/page.tsx
index 06eff4b61..3b8f68c1c 100644
--- a/src/web/src/app/c/me/[dmId]/page.tsx
+++ b/src/web/src/app/c/me/[dmId]/page.tsx
@@ -10,6 +10,10 @@ import { Avatar } from "@/components/community/avatar"
import { MessageList } from "@/components/community/messages/message-list"
import { MessageContextSheet } from "@/components/community/messages/message-context-sheet"
import { Composer, type SendAttachment } from "@/components/community/messages/composer"
+import {
+ ConversationFooterShell,
+ ConversationFooterSlotProvider,
+} from "@/components/community/messages/conversation-footer-shell"
import type { FileAttachment, ImagePreview } from "@/lib/community/models/message"
import type { OpenProfile } from "@/components/community/social/profile-types"
import {
@@ -468,81 +472,93 @@ function DmView() {
<DmHeader
dm={dm}
onBack={bp === "mobile" ? goBack : undefined}
+ typingUsers={typingUsers.map((id) => typingNames[id] ?? resolveUserName(id))}
notifLevel={(notifications.channel[dmId] ?? notifLevelDisplay("all")) as NotifLevel}
onSetNotifLevel={(level) => setNotification.mutate({ channelId: dmId, level }, {
onError: (error) => toastApiError(error, "Failed to update notification level"),
})}
/>
- <main className="flex min-h-0 flex-1 flex-col">
- <MessageList
- key={dmId}
- variant="dm"
- channel={dm.name}
- messages={messages}
- loading={loadingOwnership.messageBodyLoading}
- newDividerBefore={newDividerBefore}
- typingUsers={typingUsers.map((id) => typingNames[id] ?? resolveUserName(id))}
- onOpenThread={() => { }}
- onToggleReaction={dmBlocked ? undefined : messageActions.onToggleReaction}
- onReact={dmBlocked ? undefined : messageActions.onReact}
- onReply={dmBlocked ? undefined : messageActions.onReply}
- onCopy={messageActions.onCopy}
- onMark={dmBlocked ? undefined : messageActions.onMark}
- onRetry={dmBlocked ? undefined : messageActions.onRetry}
- onDismiss={dmBlocked ? undefined : messageActions.onDismiss}
- onPreviewImage={messageActions.onPreviewImage}
- onPreviewAttachment={messageActions.onPreviewAttachment}
- onOpenProfile={openProfile}
- resolveUserName={resolveUserName}
- onScrollRoot={setScrollRootEl}
- viewerUserId={currentUser.id}
- // Delay initial scroll until the read-state snapshot resolves AND
- // the anchor it names is actually present in `messages` — see
- // `anchorInCache`'s doc comment above.
- initialScrollReady={!readSnapshotFetching && anchorInCache}
- hasMore={hasMoreMessages}
- isFetchingOlder={isFetchingOlderMessages}
- onLoadOlder={fetchOlderMessages}
- hasMoreNewer={hasMoreNewerMessages}
- isFetchingNewer={isFetchingNewerMessages}
- onLoadNewer={fetchNewerMessages}
- onJumpToPresent={jumpToPresent}
- presentVersion={presentVersion}
- unreadCount={unreadCount}
- hero={
- <>
- <div className="relative mb-3 w-fit"><Avatar label={dm.avatar} seed={dm.userId} size={64} /></div>
- <h2 className="text-2xl font-semibold leading-tight">{dm.name}</h2>
- <p className="mt-1 text-sm text-muted-foreground">This is the beginning of your direct message history with <span className="font-medium text-foreground">{dm.name}</span>.</p>
- </>
- }
- />
- {dmBlocked ? (
- <div data-testid={tid.dmBlockedNotice} className="flex h-14 shrink-0 items-center justify-center border-t border-border/40 px-4 text-sm text-muted-foreground">
- You have blocked this user. Unblock to send messages.
- </div>
- ) : (
- <div data-onboarding-target="dm-composer" data-onboarding-name={dm.name} className="shrink-0">
- <Composer
- sendContract="accepted"
- channel={dm.name}
- context="dm"
- // DM context short-circuits `rankMentionItems` to `[]` — no popup,
- // no candidate pool needed. Passing [] keeps the Member[] typing
- // honest without shimming friends into a member shape.
- members={[]}
- channelRefCandidates={channelRefCandidates}
- channelRefCandidateSource={channelRefCandidateSource}
- onChannelRefIntent={handleChannelRefIntent}
- onAcceptSend={acceptDmSend}
- onTyping={handleTyping}
- replyingTo={replyTo ?? undefined}
- onCancelReply={() => setReplyTo(null)}
- autoFocus={bp === "desktop"}
- draftKey={`dm/${dmId}`}
- />
- </div>
- )}
+ <main
+ data-slot="community-conversation-surface"
+ data-channel-id={dmId}
+ className="flex min-h-0 flex-1 flex-col"
+ >
+ <ConversationFooterSlotProvider>
+ <MessageList
+ key={dmId}
+ variant="dm"
+ channel={dm.name}
+ messages={messages}
+ loading={loadingOwnership.messageBodyLoading}
+ newDividerBefore={newDividerBefore}
+ onOpenThread={() => { }}
+ onToggleReaction={dmBlocked ? undefined : messageActions.onToggleReaction}
+ onReact={dmBlocked ? undefined : messageActions.onReact}
+ onReply={dmBlocked ? undefined : messageActions.onReply}
+ onCopy={messageActions.onCopy}
+ onMark={dmBlocked ? undefined : messageActions.onMark}
+ onRetry={dmBlocked ? undefined : messageActions.onRetry}
+ onDismiss={dmBlocked ? undefined : messageActions.onDismiss}
+ onPreviewImage={messageActions.onPreviewImage}
+ onPreviewAttachment={messageActions.onPreviewAttachment}
+ onOpenProfile={openProfile}
+ resolveUserName={resolveUserName}
+ onScrollRoot={setScrollRootEl}
+ viewerUserId={currentUser.id}
+ // Delay initial scroll until the read-state snapshot resolves AND
+ // the anchor it names is actually present in `messages` — see
+ // `anchorInCache`'s doc comment above.
+ initialScrollReady={!readSnapshotFetching && anchorInCache}
+ hasMore={hasMoreMessages}
+ isFetchingOlder={isFetchingOlderMessages}
+ onLoadOlder={fetchOlderMessages}
+ hasMoreNewer={hasMoreNewerMessages}
+ isFetchingNewer={isFetchingNewerMessages}
+ onLoadNewer={fetchNewerMessages}
+ onJumpToPresent={jumpToPresent}
+ presentVersion={presentVersion}
+ unreadCount={unreadCount}
+ hero={
+ <>
+ <div className="relative mb-3 w-fit"><Avatar label={dm.avatar} seed={dm.userId} size={64} /></div>
+ <h2 className="text-2xl font-semibold leading-tight">{dm.name}</h2>
+ <p className="mt-1 text-sm text-muted-foreground">This is the beginning of your direct message history with <span className="font-medium text-foreground">{dm.name}</span>.</p>
+ </>
+ }
+ />
+ <ConversationFooterShell
+ data-onboarding-target="dm-composer"
+ data-onboarding-name={dm.name}
+ >
+ {dmBlocked ? (
+ <div
+ data-testid={tid.dmBlockedNotice}
+ className="flex min-h-[calc(3.75rem+var(--app-safe-area-bottom))] items-center justify-center border-t border-border/40 px-4 pb-(--app-safe-area-bottom) text-sm text-muted-foreground sm:min-h-15 sm:pb-0"
+ >
+ You have blocked this user. Unblock to send messages.
+ </div>
+ ) : (
+ <Composer
+ sendContract="accepted"
+ channel={dm.name}
+ context="dm"
+ // DM context short-circuits `rankMentionItems` to `[]` — no popup,
+ // no candidate pool needed. Passing [] keeps the Member[] typing
+ // honest without shimming friends into a member shape.
+ members={[]}
+ channelRefCandidates={channelRefCandidates}
+ channelRefCandidateSource={channelRefCandidateSource}
+ onChannelRefIntent={handleChannelRefIntent}
+ onAcceptSend={acceptDmSend}
+ onTyping={handleTyping}
+ replyingTo={replyTo ?? undefined}
+ onCancelReply={() => setReplyTo(null)}
+ autoFocus={bp === "desktop"}
+ draftKey={`dm/${dmId}`}
+ />
+ )}
+ </ConversationFooterShell>
+ </ConversationFooterSlotProvider>
</main>
<MessageContextSheet
open={contextSheetSeq !== null}
diff --git a/src/web/src/components/community/channels/channel-header.navigation.dom.test.ts b/src/web/src/components/community/channels/channel-header.navigation.dom.test.ts
index 723558a3e..cc958c019 100644
--- a/src/web/src/components/community/channels/channel-header.navigation.dom.test.ts
+++ b/src/web/src/components/community/channels/channel-header.navigation.dom.test.ts
@@ -1,6 +1,7 @@
import { createElement } from "react"
import { describe, expect, it, vi } from "vitest"
import { fireEvent, render, screen } from "@/test/react-dom-harness"
+import { tid } from "@/lib/community/testids"
import { ChannelHeader } from "./channel-header"
function renderHeader(overrides: Record<string, unknown> = {}) {
@@ -72,4 +73,10 @@ describe("ChannelHeader hierarchy navigation", () => {
expect(screen.queryByRole("button", { name: "More channel options" })).not.toBeInTheDocument()
expect(screen.getByRole("button", { name: "Open thread full screen" })).toBeInTheDocument()
})
+
+ it("owns typing presence without changing the header footprint", () => {
+ const renderer = renderHeader({ typingUsers: ["Alice"] })
+ expect(renderer.getByTestId(tid.typingIndicator)).toHaveTextContent("Alice is typing…")
+ expect(renderer.getByRole("banner")).toHaveClass("h-12", "shrink-0")
+ })
})
diff --git a/src/web/src/components/community/channels/channel-header.tsx b/src/web/src/components/community/channels/channel-header.tsx
index d1359f86d..b38a24250 100644
--- a/src/web/src/components/community/channels/channel-header.tsx
+++ b/src/web/src/components/community/channels/channel-header.tsx
@@ -19,6 +19,7 @@ import type { RightPanel } from "@/components/community/shell/panel-types"
import type { EntityKind } from "@/lib/community/models/navigation"
import { CreateDialogShell } from "../settings/create-dialog-shell"
import { tid } from "@/lib/community/testids"
+import { TypingIndicator } from "../messages/typing-indicator"
import { MessageHeader, MessageHeaderMobileBack } from "./message-header"
// Skeleton header for the loading frame between route change and channel
@@ -74,7 +75,7 @@ export type ChannelNotifLevel = typeof USE_SERVER_DEFAULT | NotifLevel
export function ChannelHeader({
channel, rightPanel, onToggle, notifLevel, onSetNotifLevel,
kind = "text", server, mobileBack, mobileBackDisplay = "viewport", onBack, tools,
- onRename, titleRename, endActions, compactActions,
+ onRename, titleRename, endActions, compactActions, typingUsers = [],
}: {
channel: string
kind?: EntityKind
@@ -91,6 +92,7 @@ export function ChannelHeader({
tools?: { threads?: boolean; pinned?: boolean; members?: boolean }
endActions?: ReactNode
compactActions?: boolean
+ typingUsers?: string[]
}) {
const tool = (k: Exclude<RightPanel, null>, Icon: LucideIcon, label: string) => (
@@ -119,6 +121,7 @@ export function ChannelHeader({
<EntityIcon kind={kind} className="size-4" />
</div>
<span className="min-w-0 truncate text-base font-semibold" title={channel}>{channel}</span>
+ <TypingIndicator names={typingUsers} variant="header" />
{onRename && (
<HeaderRename
label={channel}
diff --git a/src/web/src/components/community/channels/dm-header.test.ts b/src/web/src/components/community/channels/dm-header.test.ts
index 04f7647cf..2161154da 100644
--- a/src/web/src/components/community/channels/dm-header.test.ts
+++ b/src/web/src/components/community/channels/dm-header.test.ts
@@ -33,6 +33,17 @@ describe("DmHeader", () => {
expect(markup).toMatch(/class="[^"]*size-11[^"]*sm:hidden[^"]*"/)
expect(markup).toContain(`data-testid="${tid.dmHeaderTitle}"`)
})
+
+ it("owns typing presence inside the fixed-height header", () => {
+ const markup = renderToStaticMarkup(createElement(DmHeader, {
+ dm,
+ typingUsers: ["Alice"],
+ }))
+ expect(markup).toContain(`data-testid="${tid.typingIndicator}"`)
+ expect(markup).toContain("Alice")
+ expect(markup).toContain("is typing…")
+ expect(markup).toContain("hidden sm:inline")
+ })
})
describe("DmHeaderSkeleton", () => {
diff --git a/src/web/src/components/community/channels/dm-header.tsx b/src/web/src/components/community/channels/dm-header.tsx
index fe2264eb5..2a347c9b9 100644
--- a/src/web/src/components/community/channels/dm-header.tsx
+++ b/src/web/src/components/community/channels/dm-header.tsx
@@ -6,14 +6,23 @@ import { Skeleton } from "@/components/ui/skeleton"
import { Avatar } from "../avatar"
import type { DM } from "@/lib/community/models/people"
import { tid } from "@/lib/community/testids"
+import { TypingIndicator } from "../messages/typing-indicator"
import { MessageHeader, MessageHeaderMobileBack } from "./message-header"
-export function DmHeader({ dm, onBack, titleAs: Title = "h1", notifLevel, onSetNotifLevel }: {
+export function DmHeader({
+ dm,
+ onBack,
+ titleAs: Title = "h1",
+ notifLevel,
+ onSetNotifLevel,
+ typingUsers = [],
+}: {
dm: DM
onBack?: () => void
titleAs?: "h1" | "div"
notifLevel?: NotifLevel
onSetNotifLevel?: (level: NotifLevel) => void
+ typingUsers?: string[]
}) {
return (
<MessageHeader
@@ -31,6 +40,7 @@ export function DmHeader({ dm, onBack, titleAs: Title = "h1", notifLevel, onSetN
</span>
)}
</Title>
+ <TypingIndicator names={typingUsers} variant="header" />
</>
)}
actions={notifLevel && <DmNotifDropdown level={notifLevel} onSetLevel={onSetNotifLevel} />}
diff --git a/src/web/src/components/community/channels/text-channel-surface.dom.test.ts b/src/web/src/components/community/channels/text-channel-surface.dom.test.ts
index 3d8cdafc0..dd7ca8b33 100644
--- a/src/web/src/components/community/channels/text-channel-surface.dom.test.ts
+++ b/src/web/src/components/community/channels/text-channel-surface.dom.test.ts
@@ -6,7 +6,7 @@ import type { MessageChannelControllerValue } from "../messages/message-channel-
import { ChannelHeader } from "./channel-header"
import { TextChannelSurface } from "./text-channel-surface"
import { MessageContextSheet } from "../messages/message-context-sheet"
-import { ComposerOverlayShell } from "../messages/composer-overlay-shell"
+import { ConversationFooterShell } from "../messages/conversation-footer-shell"
import { MessageList } from "../messages/message-list"
import { useChannelMessageFeed } from "@/hooks/community/use-channel-message-feed"
import { buildAttachmentUploadFormData } from "@/hooks/community/mutations/uploads"
@@ -49,14 +49,11 @@ vi.mock("@/components/community/channels/channel-shell", () => ({
vi.mock("@/components/community/messages/composer", () => ({
Composer: vi.fn(() => null),
}))
-vi.mock("@/components/community/messages/composer-overlay-shell", () => ({
- ComposerOverlayShell: vi.fn(({ children, onOverlapChange, ...props }: {
+vi.mock("@/components/community/messages/conversation-footer-shell", () => ({
+ ConversationFooterSlotProvider: ({ children }: { children: React.ReactNode }) => children,
+ ConversationFooterShell: vi.fn(({ children, ...props }: {
children: React.ReactNode
- onOverlapChange: (overlap: number) => void
- }) => React.createElement("div", {
- ...props,
- onClick: () => onOverlapChange(96),
- }, children)),
+ }) => React.createElement("div", props, children)),
}))
vi.mock("@/components/community/messages/message-list", () => ({
MessageList: vi.fn(() => null),
@@ -120,7 +117,7 @@ function feed(overrides: Record<string, unknown> = {}) {
const mockedChannelHeader = vi.mocked(ChannelHeader)
const mockedMessageContextSheet = vi.mocked(MessageContextSheet)
-const mockedComposerOverlayShell = vi.mocked(ComposerOverlayShell)
+const mockedConversationFooterShell = vi.mocked(ConversationFooterShell)
const mockedMessageList = vi.mocked(MessageList)
const mockedUseChannelMessageFeed = vi.mocked(useChannelMessageFeed)
@@ -440,7 +437,7 @@ describe("TextChannelSurface header hierarchy", () => {
expect(mockedChannelHeader.mock.calls.at(-1)?.[0].onToggle).toEqual(expect.any(Function))
})
- it("passes measured composer overlap to the message list", () => {
+ it("keeps the composer in the shared normal-flow footer", () => {
mockedUseChannelMessageFeed.mockReturnValue(feed())
const renderer = render(React.createElement(TextChannelSurface, {
channelId: "channel_1",
@@ -462,11 +459,11 @@ describe("TextChannelSurface header hierarchy", () => {
resolveUserName: (userId: string) => userId,
}))
- expect(mockedComposerOverlayShell).toHaveBeenCalled()
+ expect(mockedConversationFooterShell).toHaveBeenCalled()
expect(renderer.container.querySelector('[data-slot="community-conversation-surface"]'))
.toHaveAttribute("data-channel-id", "channel_1")
- expect(mockedMessageList.mock.calls.at(-1)?.[0].composerOverlap).toBe(0)
- fireEvent.click(renderer.getByTestId("community-composer-shell"))
- expect(mockedMessageList.mock.calls.at(-1)?.[0].composerOverlap).toBe(96)
+ expect(mockedMessageList.mock.calls.at(-1)?.[0]).not.toHaveProperty("composerOverlap")
+ expect(mockedMessageList.mock.calls.at(-1)?.[0]).not.toHaveProperty("typingUsers")
+ expect(mockedChannelHeader.mock.calls.at(-1)?.[0].typingUsers).toEqual([])
})
})
diff --git a/src/web/src/components/community/channels/text-channel-surface.tsx b/src/web/src/components/community/channels/text-channel-surface.tsx
index 2ee38e693..e97adeced 100644
--- a/src/web/src/components/community/channels/text-channel-surface.tsx
+++ b/src/web/src/components/community/channels/text-channel-surface.tsx
@@ -8,7 +8,10 @@ import { ChannelShell } from "@/components/community/channels/channel-shell"
import { CommunityPanel } from "@/components/community/shell/community-panel"
import type { ChannelMemberPanelProps } from "@/components/community/members/channel-member-view-model"
import { Composer } from "@/components/community/messages/composer"
-import { ComposerOverlayShell } from "@/components/community/messages/composer-overlay-shell"
+import {
+ ConversationFooterShell,
+ ConversationFooterSlotProvider,
+} from "@/components/community/messages/conversation-footer-shell"
import { MessageContextSheet } from "@/components/community/messages/message-context-sheet"
import { MessageList } from "@/components/community/messages/message-list"
import { useAuthorMentionInsertion } from "@/components/community/messages/use-author-mention-insertion"
@@ -70,7 +73,6 @@ export function TextChannelSurface({
}) {
const breakpoint = useBreakpoint()
const [rightPanel, setRightPanel] = useState<RightPanel>(null)
- const [composerOverlap, setComposerOverlap] = useState(0)
const mentionInsertion = useAuthorMentionInsertion({
members: composerMembers,
viewerUserId: viewer.id,
@@ -123,6 +125,7 @@ export function TextChannelSurface({
notifLevel={notificationLevel}
onSetNotifLevel={onSetNotificationLevel}
mobileBack={onNavigateParent}
+ typingUsers={controller.typingUsers}
/>
)}
body={(
@@ -131,58 +134,57 @@ export function TextChannelSurface({
data-channel-id={channelId}
className="flex min-h-0 min-w-0 flex-1 flex-col"
>
- <MessageList
- key={channelId}
- channel={channelName}
- messages={feed.messages}
- composerOverlap={composerOverlap}
- loading={feed.isLoading}
- pinnedIds={controller.pinnedIds}
- newDividerBefore={feed.newDividerBefore}
- typingUsers={controller.typingUsers}
- onOpenThread={onOpenThread}
- {...controller.messageActions}
- onPin={canManagePins ? controller.messageActions.onPin : undefined}
- onOpenProfile={onOpenProfile}
- resolveUserName={resolveUserName}
- resolveAuthorMentionText={mentionInsertion.resolveAuthorMentionText}
- onInsertMentionText={mentionInsertion.insertMentionText}
- scrollToMessageId={controller.scrollTargetId}
- onScrollRoot={feed.setScrollRootEl}
- viewerUserId={viewer.id}
- initialScrollReady={!feed.readSnapshotFetching && feed.anchorInCache}
- onScrollTargetConsumed={controller.consumeScrollTarget}
- hasMore={feed.hasMoreOlder}
- isFetchingOlder={feed.isFetchingOlder}
- onLoadOlder={feed.fetchOlder}
- hasMoreNewer={feed.hasMoreNewer}
- isFetchingNewer={feed.isFetchingNewer}
- onLoadNewer={feed.fetchNewer}
- onJumpToPresent={feed.jumpToPresent}
- presentVersion={feed.presentVersion}
- unreadCount={feed.unreadCount}
- />
- <ComposerOverlayShell
- data-onboarding-target="channel-composer"
- data-testid={tid.channelComposerShell}
- onOverlapChange={setComposerOverlap}
- >
- <Composer
- ref={mentionInsertion.composerRef}
+ <ConversationFooterSlotProvider>
+ <MessageList
+ key={channelId}
channel={channelName}
- context="channel"
- members={composerMembers}
- mentionCandidates={composerMentionCandidates}
- channelRefCandidates={channelRefCandidates}
- sendContract="accepted"
- onAcceptSend={controller.acceptMessage}
- onTyping={controller.handleTyping}
- replyingTo={controller.replyTo ?? undefined}
- onCancelReply={() => controller.setReplyTo(null)}
- autoFocus={breakpoint === "desktop"}
- draftKey={`${serverId}/${channelId}`}
+ messages={feed.messages}
+ loading={feed.isLoading}
+ pinnedIds={controller.pinnedIds}
+ newDividerBefore={feed.newDividerBefore}
+ onOpenThread={onOpenThread}
+ {...controller.messageActions}
+ onPin={canManagePins ? controller.messageActions.onPin : undefined}
+ onOpenProfile={onOpenProfile}
+ resolveUserName={resolveUserName}
+ resolveAuthorMentionText={mentionInsertion.resolveAuthorMentionText}
+ onInsertMentionText={mentionInsertion.insertMentionText}
+ scrollToMessageId={controller.scrollTargetId}
+ onScrollRoot={feed.setScrollRootEl}
+ viewerUserId={viewer.id}
+ initialScrollReady={!feed.readSnapshotFetching && feed.anchorInCache}
+ onScrollTargetConsumed={controller.consumeScrollTarget}
+ hasMore={feed.hasMoreOlder}
+ isFetchingOlder={feed.isFetchingOlder}
+ onLoadOlder={feed.fetchOlder}
+ hasMoreNewer={feed.hasMoreNewer}
+ isFetchingNewer={feed.isFetchingNewer}
+ onLoadNewer={feed.fetchNewer}
+ onJumpToPresent={feed.jumpToPresent}
+ presentVersion={feed.presentVersion}
+ unreadCount={feed.unreadCount}
/>
- </ComposerOverlayShell>
+ <ConversationFooterShell
+ data-onboarding-target="channel-composer"
+ data-testid={tid.channelComposerShell}
+ >
+ <Composer
+ ref={mentionInsertion.composerRef}
+ channel={channelName}
+ context="channel"
+ members={composerMembers}
+ mentionCandidates={composerMentionCandidates}
+ channelRefCandidates={channelRefCandidates}
+ sendContract="accepted"
+ onAcceptSend={controller.acceptMessage}
+ onTyping={controller.handleTyping}
+ replyingTo={controller.replyTo ?? undefined}
+ onCancelReply={() => controller.setReplyTo(null)}
+ autoFocus={breakpoint === "desktop"}
+ draftKey={`${serverId}/${channelId}`}
+ />
+ </ConversationFooterShell>
+ </ConversationFooterSlotProvider>
</Body>
)}
panels={rightPanel && (
diff --git a/src/web/src/components/community/channels/thread-channel-surface.dom.test.ts b/src/web/src/components/community/channels/thread-channel-surface.dom.test.ts
index a0bc83569..e87b23dba 100644
--- a/src/web/src/components/community/channels/thread-channel-surface.dom.test.ts
+++ b/src/web/src/components/community/channels/thread-channel-surface.dom.test.ts
@@ -5,7 +5,7 @@ import { ThreadChannelSurface } from "./thread-channel-surface"
import { ChannelHeader, ChannelHeaderSkeleton } from "./channel-header"
import { CommunityPanel } from "../shell/community-panel"
import { Composer } from "../messages/composer"
-import { ComposerOverlayShell } from "../messages/composer-overlay-shell"
+import { ConversationFooterShell } from "../messages/conversation-footer-shell"
import { MessageContextSheet } from "../messages/message-context-sheet"
import { MessageList } from "../messages/message-list"
import { ThreadOpener } from "../messages/thread-opener"
@@ -67,14 +67,11 @@ vi.mock("@/components/community/messages/composer", () => ({
Composer: vi.fn(() => null),
ComposerSkeleton: vi.fn(() => null),
}))
-vi.mock("@/components/community/messages/composer-overlay-shell", () => ({
- ComposerOverlayShell: vi.fn(({ children, onOverlapChange, ...props }: {
+vi.mock("@/components/community/messages/conversation-footer-shell", () => ({
+ ConversationFooterSlotProvider: ({ children }: { children: React.ReactNode }) => children,
+ ConversationFooterShell: vi.fn(({ children, ...props }: {
children: React.ReactNode
- onOverlapChange: (overlap: number) => void
- }) => React.createElement("div", {
- ...props,
- onClick: () => onOverlapChange(96),
- }, children)),
+ }) => React.createElement("div", props, children)),
}))
vi.mock("@/components/community/messages/message-context-sheet", () => ({
MessageContextSheet: vi.fn(() => null),
@@ -142,7 +139,7 @@ const mockedChannelHeader = vi.mocked(ChannelHeader)
const mockedChannelHeaderSkeleton = vi.mocked(ChannelHeaderSkeleton)
const mockedCommunityPanel = vi.mocked(CommunityPanel)
const mockedComposer = vi.mocked(Composer)
-const mockedComposerOverlayShell = vi.mocked(ComposerOverlayShell)
+const mockedConversationFooterShell = vi.mocked(ConversationFooterShell)
const mockedMessageContextSheet = vi.mocked(MessageContextSheet)
const mockedMessageList = vi.mocked(MessageList)
const mockedUseChannelMessageFeed = vi.mocked(useChannelMessageFeed)
@@ -319,15 +316,13 @@ describe("ThreadChannelSurface ownership", () => {
expect(mocks.setReplyTo).toHaveBeenCalledWith(null)
})
- it("passes measured composer overlap to the thread message list", () => {
+ it("keeps the composer in the shared normal-flow footer", () => {
const renderer = render(React.createElement(ThreadChannelSurface, surfaceProps()))
- expect(mockedComposerOverlayShell).toHaveBeenCalled()
+ expect(mockedConversationFooterShell).toHaveBeenCalled()
expect(renderer.container.querySelector('[data-slot="community-conversation-surface"]'))
.toHaveAttribute("data-channel-id", "thread_1")
- expect(mockedMessageList.mock.calls.at(-1)?.[0].composerOverlap).toBe(0)
- fireEvent.click(renderer.getByTestId("community-composer-shell"))
- expect(mockedMessageList.mock.calls.at(-1)?.[0].composerOverlap).toBe(96)
+ expect(mockedMessageList.mock.calls.at(-1)?.[0]).not.toHaveProperty("composerOverlap")
})
it("gates live and preview Pin actions without removing the pinned panel control", () => {
@@ -363,11 +358,13 @@ describe("ThreadChannelSurface ownership", () => {
channel: "Thread name",
kind: "thread",
mobileBack: props.onNavigateParent,
+ typingUsers: ["Alice"],
}), undefined)
expect(mockedMessageList).toHaveBeenCalledWith(expect.objectContaining({
channel: "Thread name",
loading: true,
}), undefined)
+ expect(mockedMessageList.mock.calls.at(-1)?.[0]).not.toHaveProperty("typingUsers")
expect(mockedComposer).toHaveBeenCalled()
mockedUseChannelMessageFeed.mockReturnValue(feed({ isLoading: false, isError: true }))
diff --git a/src/web/src/components/community/channels/thread-channel-surface.tsx b/src/web/src/components/community/channels/thread-channel-surface.tsx
index 5d9617f3c..5f730d4d6 100644
--- a/src/web/src/components/community/channels/thread-channel-surface.tsx
+++ b/src/web/src/components/community/channels/thread-channel-surface.tsx
@@ -10,7 +10,10 @@ import { ChannelHeader, type ChannelNotifLevel } from "@/components/community/ch
import { ChannelShell } from "@/components/community/channels/channel-shell"
import { CommunityPanel } from "@/components/community/shell/community-panel"
import { Composer } from "@/components/community/messages/composer"
-import { ComposerOverlayShell } from "@/components/community/messages/composer-overlay-shell"
+import {
+ ConversationFooterShell,
+ ConversationFooterSlotProvider,
+} from "@/components/community/messages/conversation-footer-shell"
import { MessageChannelController } from "@/components/community/messages/message-channel-controller"
import { MessagePaneNavigationProvider } from "@/components/community/messages/message-pane-navigation"
import { MessageContextSheet } from "@/components/community/messages/message-context-sheet"
@@ -94,7 +97,6 @@ export function ThreadChannelSurface({
const router = useRouter()
const breakpoint = useBreakpoint()
const [rightPanel, setRightPanel] = useState<RightPanel>(null)
- const [composerOverlap, setComposerOverlap] = useState(0)
const [localName, setLocalName] = useState<string | null>(null)
const mentionInsertion = useAuthorMentionInsertion({
members: composerMembers,
@@ -217,6 +219,7 @@ export function ThreadChannelSurface({
titleRename={parentIsForum}
onRename={parentChannelId && !splitActions ? rename : undefined}
compactActions={!!splitActions}
+ typingUsers={controller.typingUsers}
endActions={splitActions ? (
<ThreadPanelActions
onFullscreen={splitActions.onFullscreen}
@@ -231,59 +234,58 @@ export function ThreadChannelSurface({
data-channel-id={channelId}
className="flex min-h-0 min-w-0 flex-1 flex-col"
>
- <MessageList
- key={channelId}
- channel={displayName}
- messages={controller.feed.messages}
- composerOverlap={composerOverlap}
- loading={controller.feed.isLoading}
- pinnedIds={controller.pinnedIds}
- newDividerBefore={controller.feed.newDividerBefore}
- typingUsers={controller.typingUsers}
- onOpenThread={ignoreNestedThread}
- {...controller.threadActions}
- onPin={canManagePins ? controller.threadActions.onPin : undefined}
- onOpenProfile={onOpenProfile}
- resolveUserName={resolveUserName}
- resolveAuthorMentionText={mentionInsertion.resolveAuthorMentionText}
- onInsertMentionText={mentionInsertion.insertMentionText}
- scrollToMessageId={controller.scrollTargetId}
- hero={opener}
- onScrollRoot={controller.feed.setScrollRootEl}
- viewerUserId={viewer.id}
- initialScrollReady={!controller.feed.readSnapshotFetching && controller.feed.anchorInCache}
- onScrollTargetConsumed={controller.consumeScrollTarget}
- hasMore={controller.feed.hasMoreOlder}
- isFetchingOlder={controller.feed.isFetchingOlder}
- onLoadOlder={controller.feed.fetchOlder}
- hasMoreNewer={controller.feed.hasMoreNewer}
- isFetchingNewer={controller.feed.isFetchingNewer}
- onLoadNewer={controller.feed.fetchNewer}
- onJumpToPresent={controller.feed.jumpToPresent}
- presentVersion={controller.feed.presentVersion}
- unreadCount={controller.feed.unreadCount}
- />
- <ComposerOverlayShell
- data-onboarding-target="channel-composer"
- data-testid={tid.channelComposerShell}
- onOverlapChange={setComposerOverlap}
- >
- <Composer
- ref={mentionInsertion.composerRef}
+ <ConversationFooterSlotProvider>
+ <MessageList
+ key={channelId}
channel={displayName}
- context="thread"
- members={composerMembers}
- mentionCandidates={composerMentionCandidates}
- channelRefCandidates={channelRefCandidates}
- sendContract="accepted"
- onAcceptSend={controller.acceptMessage}
- onTyping={controller.handleTyping}
- replyingTo={controller.replyTo ?? undefined}
- onCancelReply={() => controller.setReplyTo(null)}
- autoFocus={breakpoint === "desktop"}
- draftKey={`${serverId}/${channelId}`}
+ messages={controller.feed.messages}
+ loading={controller.feed.isLoading}
+ pinnedIds={controller.pinnedIds}
+ newDividerBefore={controller.feed.newDividerBefore}
+ onOpenThread={ignoreNestedThread}
+ {...controller.threadActions}
+ onPin={canManagePins ? controller.threadActions.onPin : undefined}
+ onOpenProfile={onOpenProfile}
+ resolveUserName={resolveUserName}
+ resolveAuthorMentionText={mentionInsertion.resolveAuthorMentionText}
+ onInsertMentionText={mentionInsertion.insertMentionText}
+ scrollToMessageId={controller.scrollTargetId}
+ hero={opener}
+ onScrollRoot={controller.feed.setScrollRootEl}
+ viewerUserId={viewer.id}
+ initialScrollReady={!controller.feed.readSnapshotFetching && controller.feed.anchorInCache}
+ onScrollTargetConsumed={controller.consumeScrollTarget}
+ hasMore={controller.feed.hasMoreOlder}
+ isFetchingOlder={controller.feed.isFetchingOlder}
+ onLoadOlder={controller.feed.fetchOlder}
+ hasMoreNewer={controller.feed.hasMoreNewer}
+ isFetchingNewer={controller.feed.isFetchingNewer}
+ onLoadNewer={controller.feed.fetchNewer}
+ onJumpToPresent={controller.feed.jumpToPresent}
+ presentVersion={controller.feed.presentVersion}
+ unreadCount={controller.feed.unreadCount}
/>
- </ComposerOverlayShell>
+ <ConversationFooterShell
+ data-onboarding-target="channel-composer"
+ data-testid={tid.channelComposerShell}
+ >
+ <Composer
+ ref={mentionInsertion.composerRef}
+ channel={displayName}
+ context="thread"
+ members={composerMembers}
+ mentionCandidates={composerMentionCandidates}
+ channelRefCandidates={channelRefCandidates}
+ sendContract="accepted"
+ onAcceptSend={controller.acceptMessage}
+ onTyping={controller.handleTyping}
+ replyingTo={controller.replyTo ?? undefined}
+ onCancelReply={() => controller.setReplyTo(null)}
+ autoFocus={breakpoint === "desktop"}
+ draftKey={`${serverId}/${channelId}`}
+ />
+ </ConversationFooterShell>
+ </ConversationFooterSlotProvider>
</Body>
)}
panels={rightPanel && (
diff --git a/src/web/src/components/community/messages/composer-accessory-rail-layout.test.ts b/src/web/src/components/community/messages/composer-accessory-rail-layout.test.ts
deleted file mode 100644
index f9cb3fd67..000000000
--- a/src/web/src/components/community/messages/composer-accessory-rail-layout.test.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest"
-import {
- allocateComposerAccessoryRail,
- type ComposerAccessoryRailLayout,
-} from "./composer-accessory-rail-layout"
-
-describe("allocateComposerAccessoryRail", () => {
- it.each([
- [false, false, "empty"],
- [true, false, "left-only"],
- [false, true, "centered"],
- [true, true, "centered"],
- ] satisfies Array<[boolean, boolean, ComposerAccessoryRailLayout]>) (
- "maps normal left=%s center=%s to %s",
- (left, center, expected) => {
- expect(allocateComposerAccessoryRail({ mode: "normal", left, center })).toBe(expected)
- },
- )
-
- it("keeps selection centered independently of side occupancy", () => {
- expect(allocateComposerAccessoryRail({ mode: "selection" })).toBe("centered")
- })
-})
diff --git a/src/web/src/components/community/messages/composer-accessory-rail-layout.ts b/src/web/src/components/community/messages/composer-accessory-rail-layout.ts
deleted file mode 100644
index ab1fc9151..000000000
--- a/src/web/src/components/community/messages/composer-accessory-rail-layout.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-export type ComposerAccessoryRailOccupancy =
- | {
- mode: "normal"
- left: boolean
- center: boolean
- }
- | {
- mode: "selection"
- }
-
-export type ComposerAccessoryRailLayout =
- | "empty"
- | "centered"
- | "left-only"
-
-export function allocateComposerAccessoryRail(
- occupancy: ComposerAccessoryRailOccupancy,
-): ComposerAccessoryRailLayout {
- if (occupancy.mode === "selection") return "centered"
- if (occupancy.center) return "centered"
- if (occupancy.left) return "left-only"
- return "empty"
-}
diff --git a/src/web/src/components/community/messages/composer-accessory-rail.dom.test.ts b/src/web/src/components/community/messages/composer-accessory-rail.dom.test.ts
index 0b0f300c8..ac442f3ce 100644
--- a/src/web/src/components/community/messages/composer-accessory-rail.dom.test.ts
+++ b/src/web/src/components/community/messages/composer-accessory-rail.dom.test.ts
@@ -4,8 +4,8 @@ import { resolve } from "node:path"
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
import { tid } from "@/lib/community/testids"
import { useCommunityWsStore } from "@/stores/community/ws"
-import { fireEvent, render as rtlRender, type RenderResult } from "@/test/react-dom-harness"
-import { ComposerAccessoryRail, selectionTypingFits } from "./composer-accessory-rail"
+import { fireEvent, render } from "@/test/react-dom-harness"
+import { ComposerAccessoryRail, MessageSelectionFooter } from "./composer-accessory-rail"
vi.mock("@/components/ui/number-ticker", () => ({
NumberTicker: ({ value }: { value: number }) => React.createElement("ticker", { value }),
@@ -14,25 +14,19 @@ vi.mock("@/components/ui/number-ticker", () => ({
vi.mock("@/components/ui/tooltip", () => ({
Tooltip: ({ children }: { children: React.ReactNode }) => React.createElement("tooltip", null, children),
TooltipTrigger: ({
- render,
+ render: trigger,
children,
}: {
render: React.ReactElement
children: React.ReactNode
- }) => React.cloneElement(render, {}, children),
+ }) => React.cloneElement(trigger, {}, children),
TooltipContent: ({ children }: { children: React.ReactNode }) => React.createElement("tooltip-content", null, children),
}))
-const baseProps = {
- typingNames: [] as string[],
+const railProps = {
scrollCount: 4,
scrollMode: "jump" as const,
onScroll: vi.fn(),
- selectMode: false,
- selectedCount: 0,
- onCancelSelection: vi.fn(),
- onShareSelection: vi.fn(),
- composerOverlap: 0,
}
describe("ComposerAccessoryRail", () => {
@@ -45,131 +39,68 @@ describe("ComposerAccessoryRail", () => {
useCommunityWsStore.getState().reset()
})
- function renderRail(overrides: Partial<typeof baseProps> = {}) {
- return rtlRender(React.createElement(ComposerAccessoryRail, {
- ...baseProps,
- ...overrides,
- }))
- }
-
- function slotClassName(renderer: RenderResult, testId: string): string {
- const node = renderer.getByTestId(testId).closest('div[class*="col-start-"]')
- expect(node, `${testId} must have a bounded grid slot`).not.toBeNull()
- return node!.className
- }
-
- it.each([
- [false, false, "empty"],
- [true, false, "left-only"],
- [false, true, "centered"],
- [true, true, "centered"],
- ] as const)(
- "renders typing=%s scroll=%s as %s",
- (typing, center, layout) => {
- const renderer = renderRail({
- typingNames: typing ? ["Alice"] : [],
- scrollCount: center ? 2 : 0,
- })
- const rails = renderer.queryAllByTestId(tid.composerAccessoryRail)
- expect(rails).toHaveLength(layout === "empty" ? 0 : 1)
- expect(renderer.queryAllByTestId(tid.scrollToPresent))
- .toHaveLength(center ? 1 : 0)
- expect(renderer.queryAllByTestId(tid.typingIndicator))
- .toHaveLength(typing ? 1 : 0)
- if (layout === "empty") return
-
- expect(rails[0]).toHaveAttribute("data-layout", layout)
- if (center) expect(slotClassName(renderer, tid.scrollToPresent)).toContain("col-start-2")
- if (typing) expect(slotClassName(renderer, tid.typingIndicator)).toContain("col-start-1")
- },
- )
-
- it("keeps selection centered, hides typing when it cannot fit, and wires its actions", () => {
- const renderer = renderRail({
- typingNames: ["Alice"],
- selectMode: true,
- selectedCount: 12,
- })
+ it("renders only the away scroll control and preserves its floating boundary", () => {
+ const renderer = render(React.createElement(ComposerAccessoryRail, railProps))
const rail = renderer.getByTestId(tid.composerAccessoryRail)
expect(rail).toHaveAttribute("data-layout", "centered")
- expect(rail).toHaveAttribute("data-selection", "active")
- expect(renderer.queryAllByTestId(tid.scrollToPresent)).toHaveLength(0)
- expect(slotClassName(renderer, tid.messageSelectionToolbar)).toContain("col-start-2")
- const typingSlot = slotClassName(renderer, tid.typingIndicator)
- expect(typingSlot).toContain("col-start-1")
- expect(typingSlot).not.toContain("sm:block")
- expect(renderer.container.querySelector('[data-selection-typing-fit="hidden"]')).not.toBeNull()
-
- const toolbar = renderer.getByTestId(tid.messageSelectionToolbar)
- expect(toolbar).toHaveClass("h-10", "max-w-full")
- const cancel = renderer.getByRole("button", { name: "Cancel message selection" })
- const share = renderer.getByRole("button", {
- name: "Share 12 selected messages as image",
- })
- expect(cancel).toHaveClass("w-11", "text-foreground")
- expect(cancel.querySelector("svg")).toHaveClass("text-foreground")
- const cancelLabel = Array.from(cancel.querySelectorAll("span"))
- .find((node) => node.textContent === "Cancel")
- expect(cancelLabel).toHaveClass("text-foreground")
- expect(share).toHaveClass("after:-inset-y-1.5")
- fireEvent.click(cancel)
- fireEvent.click(share)
- expect(baseProps.onCancelSelection).toHaveBeenCalledOnce()
- expect(baseProps.onShareSelection).toHaveBeenCalledOnce()
- })
-
- it("shows selection typing only when the complete intrinsic pill fits", () => {
- expect(selectionTypingFits(160, 160)).toBe(true)
- expect(selectionTypingFits(160, 159.5)).toBe(true)
- expect(selectionTypingFits(160, 160.5)).toBe(false)
- expect(selectionTypingFits(0, 0)).toBe(false)
- })
-
- it("centers the scroll control, preserves the floating boundary, and wires scroll", () => {
- const renderer = renderRail()
- const rail = renderer.getByTestId(tid.composerAccessoryRail)
- expect(rail).toHaveClass("absolute")
- const railClasses = rail.className.split(" ")
- expect(railClasses).toContain("bottom-2")
- expect(railClasses).toContain("sm:bottom-4")
- expect(railClasses).not.toContain("bottom-3")
- expect(rail).toHaveStyle({ transform: "translateY(-0px)" })
- expect(rail).toHaveAttribute("data-layout", "centered")
+ expect(rail).toHaveClass("absolute", "bottom-2", "sm:bottom-4")
+ expect(rail).not.toHaveAttribute("style")
const scroll = renderer.getByTestId(tid.scrollToPresent)
expect(scroll).toHaveAttribute("aria-label", "Jump to present, 4 unread below")
- const grid = rail.querySelector<HTMLElement>("div.grid.w-full")!
- expect(grid.className)
- .toContain("grid-cols-[minmax(0,1fr)_minmax(0,max-content)_minmax(0,1fr)]")
+ expect(scroll.closest('div[class*="col-start-"]')).toHaveClass("col-start-2")
fireEvent.click(scroll)
- expect(baseProps.onScroll).toHaveBeenCalledOnce()
- })
-
- it("moves above the live composer overlap", () => {
- const renderer = renderRail({ composerOverlap: 96 })
- expect(renderer.getByTestId(tid.composerAccessoryRail))
- .toHaveStyle({ transform: "translateY(-96px)" })
+ expect(railProps.onScroll).toHaveBeenCalledOnce()
})
- it("never reserves composer space for WebSocket state", () => {
+ it("stays absent at the tail regardless of WebSocket state", () => {
+ const renderEmpty = () => render(React.createElement(ComposerAccessoryRail, {
+ ...railProps,
+ scrollCount: 0,
+ }))
useCommunityWsStore.getState().setConnectionStatus("reconnecting")
- const empty = renderRail({ scrollCount: 0 })
- expect(empty.queryAllByTestId(tid.composerAccessoryRail)).toHaveLength(0)
-
+ expect(renderEmpty().queryAllByTestId(tid.composerAccessoryRail)).toHaveLength(0)
useCommunityWsStore.getState().setConnectionStatus("failed")
- const failed = renderRail({ scrollCount: 0 })
+ const failed = renderEmpty()
expect(failed.queryAllByTestId(tid.composerAccessoryRail)).toHaveLength(0)
expect(failed.queryAllByTestId(tid.wsRetry)).toHaveLength(0)
})
- it("does not reintroduce WS ownership or a viewport-derived width cap", () => {
+ it("keeps typing and selection ownership out of the viewport rail", () => {
const source = readFileSync(resolve(
process.cwd(),
process.cwd().endsWith("/src/web") ? "" : "src/web",
"src/components/community/messages/composer-accessory-rail.tsx",
), "utf8")
expect(source).not.toContain("@/stores/community/ws")
- expect(source).not.toContain("WsStatusControl")
+ expect(source).not.toContain("TypingIndicator")
+ expect(source).not.toContain("selectionTypingFits")
expect(source).not.toMatch(/max-w-\[calc\([^\]]*vw/)
- expect(source).not.toContain('className="hidden min-w-0 max-w-full sm:col-start-1 sm:block"')
+ })
+})
+
+describe("MessageSelectionFooter", () => {
+ it("fills the composer slot and wires cancel and share actions", () => {
+ const onCancel = vi.fn()
+ const onShare = vi.fn()
+ const renderer = render(React.createElement(MessageSelectionFooter, {
+ selectedCount: 12,
+ onCancel,
+ onShare,
+ }))
+ const footer = renderer.container.querySelector('[data-selection="active"]')
+ expect(footer).toHaveClass("absolute", "inset-0", "bg-(--app-bg)")
+ const toolbar = renderer.getByTestId(tid.messageSelectionToolbar)
+ expect(toolbar).toHaveClass("h-10", "max-w-full")
+ const cancel = renderer.getByRole("button", { name: "Cancel message selection" })
+ const share = renderer.getByRole("button", {
+ name: "Share 12 selected messages as image",
+ })
+ expect(cancel).toHaveClass("w-11", "text-foreground")
+ expect(cancel.querySelector("svg")).toHaveClass("text-foreground")
+ expect(share).toHaveClass("after:-inset-y-1.5")
+ fireEvent.click(cancel)
+ fireEvent.click(share)
+ expect(onCancel).toHaveBeenCalledOnce()
+ expect(onShare).toHaveBeenCalledOnce()
})
})
diff --git a/src/web/src/components/community/messages/composer-accessory-rail.tsx b/src/web/src/components/community/messages/composer-accessory-rail.tsx
index 1b45239a1..39cfb5a96 100644
--- a/src/web/src/components/community/messages/composer-accessory-rail.tsx
+++ b/src/web/src/components/community/messages/composer-accessory-rail.tsx
@@ -1,144 +1,52 @@
"use client"
-import { useLayoutEffect, useMemo, useRef, useState } from "react"
import { ArrowDown, ImageIcon, X } from "lucide-react"
import { Button } from "@/components/ui/button"
import { NumberTicker } from "@/components/ui/number-ticker"
import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
import { tid } from "@/lib/community/testids"
-import { cn } from "@/lib/utils"
-import { allocateComposerAccessoryRail } from "./composer-accessory-rail-layout"
-import { TypingIndicator } from "./typing-indicator"
export function ComposerAccessoryRail({
- typingNames,
scrollCount,
scrollMode,
onScroll,
- selectMode,
- selectedCount,
- onCancelSelection,
- onShareSelection,
- composerOverlap,
}: {
- typingNames: string[]
scrollCount: number
scrollMode: "scroll" | "jump"
onScroll: () => void
- selectMode: boolean
- selectedCount: number
- onCancelSelection: () => void
- onShareSelection: () => void
- composerOverlap: number
}) {
- const hasTyping = typingNames.length > 0
- const hasScroll = scrollCount > 0
- const layout = allocateComposerAccessoryRail(selectMode
- ? { mode: "selection" }
- : { mode: "normal", left: hasTyping, center: hasScroll })
-
- if (layout === "empty") return null
+ if (scrollCount <= 0) return null
return (
<div
data-testid={tid.composerAccessoryRail}
- data-selection={selectMode ? "active" : "inactive"}
- data-layout={layout}
+ data-layout="centered"
className="pointer-events-none absolute inset-x-0 bottom-2 z-20 px-2 sm:bottom-4 sm:px-4"
- style={{ transform: `translateY(-${composerOverlap}px)` }}
>
- <div
- className={cn(
- "grid w-full items-end gap-1 sm:gap-2",
- layout === "centered" && "grid-cols-[minmax(0,1fr)_minmax(0,max-content)_minmax(0,1fr)]",
- layout === "left-only" && "grid-cols-[minmax(0,1fr)]",
- )}
- >
- {selectMode ? (
- <>
- {hasTyping && (
- <SelectionTypingIndicator key="left" names={typingNames} />
- )}
- <div key="center" className="col-start-2 min-w-0 max-w-full justify-self-center">
- <SelectionToolbar
- selectedCount={selectedCount}
- onCancel={onCancelSelection}
- onShare={onShareSelection}
- />
- </div>
- </>
- ) : (
- <>
- {hasTyping && (
- <div key="left" className="col-start-1 min-w-0 max-w-full">
- <TypingIndicator names={typingNames} className="w-fit max-w-full" />
- </div>
- )}
- {hasScroll && (
- <div key="center" className="col-start-2 min-w-0 max-w-full justify-self-center">
- <ScrollControl count={scrollCount} mode={scrollMode} onClick={onScroll} />
- </div>
- )}
- </>
- )}
+ <div className="grid w-full grid-cols-[minmax(0,1fr)_minmax(0,max-content)_minmax(0,1fr)] items-end">
+ <div className="col-start-2 min-w-0 max-w-full justify-self-center">
+ <ScrollControl count={scrollCount} mode={scrollMode} onClick={onScroll} />
+ </div>
</div>
</div>
)
}
-export function selectionTypingFits(slotWidth: number, pillWidth: number): boolean {
- return slotWidth > 0 && pillWidth > 0 && pillWidth <= slotWidth
-}
-
-function SelectionTypingIndicator({ names }: { names: string[] }) {
- const slotRef = useRef<HTMLDivElement>(null)
- const pillRef = useRef<HTMLDivElement>(null)
- const measurementKey = useMemo(() => JSON.stringify(names), [names])
- const [measurement, setMeasurement] = useState({ key: "", fits: false })
- const isMeasured = measurement.key === measurementKey
- const isVisible = isMeasured && measurement.fits
-
- useLayoutEffect(() => {
- const slot = slotRef.current
- const pill = pillRef.current
- if (!slot || !pill) return
-
- const measure = () => {
- const fits = selectionTypingFits(
- slot.getBoundingClientRect().width,
- pill.getBoundingClientRect().width,
- )
- setMeasurement((current) => (
- current.key === measurementKey && current.fits === fits
- ? current
- : { key: measurementKey, fits }
- ))
- }
-
- measure()
- if (typeof ResizeObserver === "undefined") return
- const observer = new ResizeObserver(measure)
- observer.observe(slot)
- observer.observe(pill)
- return () => observer.disconnect()
- }, [measurementKey])
-
+export function MessageSelectionFooter({
+ selectedCount,
+ onCancel,
+ onShare,
+}: {
+ selectedCount: number
+ onCancel: () => void
+ onShare: () => void
+}) {
return (
<div
- ref={slotRef}
- data-selection-typing-fit={isMeasured ? (isVisible ? "visible" : "hidden") : "pending"}
- className="relative col-start-1 min-w-0 max-w-full"
+ data-selection="active"
+ className="pointer-events-auto absolute inset-0 flex items-center justify-center bg-(--app-bg) px-2 pb-(--app-safe-area-bottom) sm:px-4 sm:pb-0"
>
- <div
- ref={pillRef}
- aria-hidden={!isVisible}
- className={cn(
- "w-max max-w-none",
- isVisible ? "relative" : "invisible absolute bottom-0 left-0",
- )}
- >
- <TypingIndicator names={names} />
- </div>
+ <SelectionToolbar selectedCount={selectedCount} onCancel={onCancel} onShare={onShare} />
</div>
)
}
diff --git a/src/web/src/components/community/messages/composer-overlay-shell.dom.test.tsx b/src/web/src/components/community/messages/composer-overlay-shell.dom.test.tsx
deleted file mode 100644
index c07f81d1d..000000000
--- a/src/web/src/components/community/messages/composer-overlay-shell.dom.test.tsx
+++ /dev/null
@@ -1,71 +0,0 @@
-import React from "react"
-import { act, render } from "@/test/react-dom-harness"
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { ComposerOverlayShell } from "./composer-overlay-shell"
-
-let resize: ResizeObserverCallback | null = null
-let shellHeight = 60
-let overlayHeight = 60
-let offsetHeightDescriptor: PropertyDescriptor | undefined
-
-beforeEach(() => {
- resize = null
- shellHeight = 60
- overlayHeight = 60
- offsetHeightDescriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "offsetHeight")
- Object.defineProperty(HTMLElement.prototype, "offsetHeight", {
- configurable: true,
- get() {
- const slot = (this as HTMLElement).dataset.slot
- if (slot === "community-composer-shell") return shellHeight
- if (slot === "community-composer-overlay") return overlayHeight
- return 0
- },
- })
- vi.stubGlobal("ResizeObserver", class {
- constructor(callback: ResizeObserverCallback) { resize = callback }
- observe() {}
- disconnect() {}
- unobserve() {}
- })
-})
-
-afterEach(() => {
- vi.unstubAllGlobals()
- if (offsetHeightDescriptor) {
- Object.defineProperty(HTMLElement.prototype, "offsetHeight", offsetHeightDescriptor)
- } else {
- delete (HTMLElement.prototype as unknown as { offsetHeight?: unknown }).offsetHeight
- }
-})
-
-describe("ComposerOverlayShell", () => {
- it("reserves the collapsed height and reports only upward overlap", () => {
- const onOverlapChange = vi.fn()
- const renderer = render(
- <ComposerOverlayShell onOverlapChange={onOverlapChange} data-testid="shell">
- <div>composer</div>
- </ComposerOverlayShell>,
- )
-
- const shell = renderer.getByTestId("shell")
- expect(shell).toHaveClass("relative", "shrink-0")
- expect(shell.className).toContain("h-[calc(3.75rem+var(--app-safe-area-bottom))]")
- expect(shell).toHaveClass("sm:h-15")
- expect(shell.querySelector('[data-slot="community-composer-overlay"]'))
- .toHaveClass("absolute", "inset-x-0", "bottom-0", "z-30")
- expect(onOverlapChange).toHaveBeenLastCalledWith(0)
-
- overlayHeight = 156
- act(() => resize?.([], {} as ResizeObserver))
- expect(onOverlapChange).toHaveBeenLastCalledWith(96)
-
- overlayHeight = 84
- act(() => resize?.([], {} as ResizeObserver))
- expect(onOverlapChange).toHaveBeenLastCalledWith(24)
-
- overlayHeight = 48
- act(() => resize?.([], {} as ResizeObserver))
- expect(onOverlapChange).toHaveBeenLastCalledWith(0)
- })
-})
diff --git a/src/web/src/components/community/messages/composer-overlay-shell.tsx b/src/web/src/components/community/messages/composer-overlay-shell.tsx
deleted file mode 100644
index 18198270e..000000000
--- a/src/web/src/components/community/messages/composer-overlay-shell.tsx
+++ /dev/null
@@ -1,56 +0,0 @@
-"use client"
-
-import { useLayoutEffect, useRef, type HTMLAttributes, type ReactNode } from "react"
-
-export function ComposerOverlayShell({
- children,
- className,
- onOverlapChange,
- ...props
-}: Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
- children: ReactNode
- onOverlapChange: (overlap: number) => void
-}) {
- const shellRef = useRef<HTMLDivElement>(null)
- const overlayRef = useRef<HTMLDivElement>(null)
- const overlapRef = useRef<number | null>(null)
-
- useLayoutEffect(() => {
- const shell = shellRef.current
- const overlay = overlayRef.current
- if (!shell || !overlay) return
-
- const measure = () => {
- const overlap = Math.max(0, overlay.offsetHeight - shell.offsetHeight)
- if (overlap === overlapRef.current) return
- overlapRef.current = overlap
- onOverlapChange(overlap)
- }
-
- measure()
- if (typeof ResizeObserver === "undefined") return
- const observer = new ResizeObserver(measure)
- observer.observe(shell)
- observer.observe(overlay)
- return () => observer.disconnect()
- }, [onOverlapChange])
-
- return (
- <div
- {...props}
- ref={shellRef}
- data-slot="community-composer-shell"
- className={`relative h-[calc(3.75rem+var(--app-safe-area-bottom))] shrink-0 sm:h-15${
- className ? ` ${className}` : ""
- }`}
- >
- <div
- ref={overlayRef}
- data-slot="community-composer-overlay"
- className="absolute inset-x-0 bottom-0 z-30"
- >
- {children}
- </div>
- </div>
- )
-}
diff --git a/src/web/src/components/community/messages/composer-view.dom.test.ts b/src/web/src/components/community/messages/composer-view.dom.test.ts
index 25484e962..59b46705e 100644
--- a/src/web/src/components/community/messages/composer-view.dom.test.ts
+++ b/src/web/src/components/community/messages/composer-view.dom.test.ts
@@ -246,6 +246,9 @@ describe("ComposerView", () => {
expect(
renderer.container.querySelector('[class*="focus-within:ring-2"]')?.className,
).toContain("rounded-(--community-composer-top-radius)")
+ expect(renderer.container.querySelector("[data-editor-content]")?.className).toContain(
+ "max-h-48",
+ )
renderer.rerender(createElement(
ComposerView,
diff --git a/src/web/src/components/community/messages/composer-view.tsx b/src/web/src/components/community/messages/composer-view.tsx
index 00ab6c381..fa5604638 100644
--- a/src/web/src/components/community/messages/composer-view.tsx
+++ b/src/web/src/components/community/messages/composer-view.tsx
@@ -206,7 +206,7 @@ export function ComposerView({
>
<EditorContent
editor={editor}
- className={`${isForumThreadBody ? "max-h-60" : "max-h-40"} overflow-y-auto thin-scrollbar text-base chat-input-line-height outline-none`}
+ className={`${isForumThreadBody ? "max-h-60" : "max-h-48"} overflow-y-auto thin-scrollbar text-base chat-input-line-height outline-none`}
/>
</div>
{!hideAttach && (
diff --git a/src/web/src/components/community/messages/conversation-footer-shell.dom.test.tsx b/src/web/src/components/community/messages/conversation-footer-shell.dom.test.tsx
new file mode 100644
index 000000000..80cda8892
--- /dev/null
+++ b/src/web/src/components/community/messages/conversation-footer-shell.dom.test.tsx
@@ -0,0 +1,59 @@
+import React from "react"
+import { fireEvent, render } from "@/test/react-dom-harness"
+import { describe, expect, it } from "vitest"
+import {
+ ConversationFooterShell,
+ ConversationFooterSlotProvider,
+ useConversationFooterSlot,
+} from "./conversation-footer-shell"
+
+describe("ConversationFooterShell", () => {
+ it("keeps ordinary composer content in normal flow", () => {
+ const renderer = render(
+ <ConversationFooterShell data-testid="footer">
+ <div data-testid="composer-editor">composer</div>
+ </ConversationFooterShell>,
+ )
+
+ const footer = renderer.getByTestId("footer")
+ expect(footer).toHaveClass("relative", "shrink-0")
+ expect(footer).toHaveAttribute("data-slot", "community-conversation-footer")
+ expect(footer).toHaveAttribute("data-selection-active", "false")
+ expect(renderer.getByTestId("composer-editor").parentElement)
+ .not.toHaveClass("absolute", "invisible", "h-0")
+ expect(footer.querySelector('[data-slot="community-selection-footer-slot"]'))
+ .toHaveClass("hidden")
+ expect(footer.querySelector('[data-slot="community-composer-overlay"]')).toBeNull()
+ })
+
+ it("replaces the mounted composer with an explicit in-flow selection slot", () => {
+ function SelectionToggle() {
+ const footer = useConversationFooterSlot()!
+ return (
+ <button type="button" onClick={() => footer.setSelectionActive(true)}>
+ select
+ </button>
+ )
+ }
+ const renderer = render(
+ <ConversationFooterSlotProvider>
+ <SelectionToggle />
+ <ConversationFooterShell data-testid="footer">
+ <div data-testid="composer-editor">draft</div>
+ </ConversationFooterShell>
+ </ConversationFooterSlotProvider>,
+ )
+ const footer = renderer.getByTestId("footer")
+ const editor = renderer.getByTestId("composer-editor")
+
+ fireEvent.click(renderer.getByRole("button", { name: "select" }))
+
+ expect(footer).toHaveAttribute("data-selection-active", "true")
+ expect(editor).toBeInTheDocument()
+ expect(editor.parentElement).toHaveClass("invisible", "h-0", "overflow-hidden")
+ expect(footer.querySelector('[data-slot="community-selection-footer-slot"]'))
+ .toHaveClass("relative", "h-[calc(3.75rem+var(--app-safe-area-bottom))]", "sm:h-15")
+ expect(footer.querySelector('[data-slot="community-selection-footer-slot"]'))
+ .not.toHaveClass("absolute", "inset-0", "hidden")
+ })
+})
diff --git a/src/web/src/components/community/messages/conversation-footer-shell.tsx b/src/web/src/components/community/messages/conversation-footer-shell.tsx
new file mode 100644
index 000000000..9434e283f
--- /dev/null
+++ b/src/web/src/components/community/messages/conversation-footer-shell.tsx
@@ -0,0 +1,90 @@
+"use client"
+
+import {
+ createContext,
+ useCallback,
+ useContext,
+ useMemo,
+ useState,
+ type Dispatch,
+ type HTMLAttributes,
+ type ReactNode,
+ type SetStateAction,
+} from "react"
+
+type ConversationFooterSlot = {
+ target: HTMLDivElement | null
+ setTarget: Dispatch<SetStateAction<HTMLDivElement | null>>
+ selectionActive: boolean
+ setSelectionActive: Dispatch<SetStateAction<boolean>>
+}
+
+const ConversationFooterSlotContext = createContext<ConversationFooterSlot | null>(null)
+
+export function ConversationFooterSlotProvider({ children }: { children: ReactNode }) {
+ const [target, setTarget] = useState<HTMLDivElement | null>(null)
+ const [selectionActive, setSelectionActive] = useState(false)
+ const value = useMemo(() => ({
+ target,
+ setTarget,
+ selectionActive,
+ setSelectionActive,
+ }), [selectionActive, target])
+
+ return (
+ <ConversationFooterSlotContext.Provider value={value}>
+ {children}
+ </ConversationFooterSlotContext.Provider>
+ )
+}
+
+export function useConversationFooterSlot(): ConversationFooterSlot | null {
+ return useContext(ConversationFooterSlotContext)
+}
+
+/**
+ * The single in-flow footer owner for a conversation surface.
+ *
+ * Composer content grows naturally and the message viewport consumes the
+ * remaining height. Selection replaces that content with an explicit
+ * one-line footer slot instead of layering another hitbox over the message
+ * list.
+ */
+export function ConversationFooterShell({
+ children,
+ className,
+ ...props
+}: Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+ children: ReactNode
+}) {
+ const footerSlot = useConversationFooterSlot()
+ const setFooterTarget = footerSlot?.setTarget
+ const bindFooterTarget = useCallback((target: HTMLDivElement | null) => {
+ setFooterTarget?.(target)
+ }, [setFooterTarget])
+ const selectionActive = footerSlot?.selectionActive ?? false
+
+ return (
+ <div
+ {...props}
+ data-slot="community-conversation-footer"
+ data-selection-active={selectionActive ? "true" : "false"}
+ className={`relative shrink-0${className ? ` ${className}` : ""}`}
+ >
+ <div
+ aria-hidden={selectionActive || undefined}
+ inert={selectionActive || undefined}
+ className={selectionActive ? "invisible h-0 overflow-hidden" : undefined}
+ >
+ {children}
+ </div>
+ <div
+ ref={bindFooterTarget}
+ data-slot="community-selection-footer-slot"
+ className={selectionActive
+ ? "relative h-[calc(3.75rem+var(--app-safe-area-bottom))] sm:h-15"
+ : "hidden"}
+ />
+ </div>
+ )
+}
diff --git a/src/web/src/components/community/messages/message-list-controller.dom.test.ts b/src/web/src/components/community/messages/message-list-controller.dom.test.ts
index 7e07d7bac..450eb4d29 100644
--- a/src/web/src/components/community/messages/message-list-controller.dom.test.ts
+++ b/src/web/src/components/community/messages/message-list-controller.dom.test.ts
@@ -21,6 +21,7 @@ const mocks = vi.hoisted(() => ({
scrollToBottom: vi.fn(),
onImageLoad: vi.fn(),
captureOlderPageAnchor: vi.fn(),
+ captureNewerPageAnchor: vi.fn(),
}))
vi.mock("@/hooks/community/use-scroll-anchor", () => ({
@@ -36,6 +37,8 @@ vi.mock("@/hooks/community/use-scroll-anchor", () => ({
onImageLoad: mocks.onImageLoad,
captureOlderPageAnchor: mocks.captureOlderPageAnchor,
isOlderPageAnchorSettling: false,
+ captureNewerPageAnchor: mocks.captureNewerPageAnchor,
+ isNewerPageAnchorSettling: false,
}
},
}))
@@ -65,7 +68,6 @@ function props(overrides: Partial<ResolvedMessageListProps> = {}): ResolvedMessa
onOpenThread: vi.fn(),
variant: "channel",
initialScrollReady: true,
- composerOverlap: 0,
...overrides,
}
}
@@ -106,8 +108,6 @@ describe("useMessageListController", () => {
let requestFrame: ReturnType<typeof vi.fn>
let cancelFrame: ReturnType<typeof vi.fn>
let visibleMessageIds: string[]
- let selectionRailTop: number | null
- let selectedRowBottom: number
const disconnect = vi.fn()
const heroNode = { offsetHeight: 0 }
const scrollNode = {
@@ -115,14 +115,9 @@ describe("useMessageListController", () => {
scrollHeight: 3206,
clientHeight: 692,
isConnected: true,
- parentElement: {
- querySelector: () => selectionRailTop === null ? null : ({
- getBoundingClientRect: () => ({ top: selectionRailTop }),
- }),
- },
querySelectorAll: () => visibleMessageIds.map((id) => ({
dataset: { msgId: id },
- getBoundingClientRect: () => ({ top: 10, bottom: selectedRowBottom }),
+ getBoundingClientRect: () => ({ top: 10, bottom: 20 }),
})),
getBoundingClientRect: () => ({ top: 0, bottom: 100 }),
}
@@ -143,8 +138,6 @@ describe("useMessageListController", () => {
nextFrameId = 0
frameCallbacks = new Map()
visibleMessageIds = ["m1"]
- selectionRailTop = null
- selectedRowBottom = 20
scrollNode.scrollTop = 0
scrollNode.clientHeight = 692
heroNode.offsetHeight = 0
@@ -196,6 +189,7 @@ describe("useMessageListController", () => {
initialScrollReady: true,
hasMoreNewer: undefined,
isFetchingOlder: undefined,
+ isFetchingNewer: undefined,
presentVersion: undefined,
viewerUserId: undefined,
heroHeight: 0,
@@ -216,6 +210,8 @@ describe("useMessageListController", () => {
scrollRef: mocks.scrollRef,
hasMore: undefined,
isFetching: undefined,
+ isSettling: false,
+ onBeforeLoad: mocks.captureNewerPageAnchor,
onLoad: undefined,
edge: "end",
},
@@ -302,6 +298,7 @@ describe("useMessageListController", () => {
initialScrollReady: false,
hasMoreNewer: true,
isFetchingOlder: true,
+ isFetchingNewer: true,
presentVersion: 7,
viewerUserId: "viewer_1",
heroHeight: 0,
@@ -322,6 +319,8 @@ describe("useMessageListController", () => {
scrollRef: mocks.scrollRef,
hasMore: true,
isFetching: true,
+ isSettling: false,
+ onBeforeLoad: mocks.captureNewerPageAnchor,
onLoad: loadNewer,
edge: "end",
},
@@ -522,75 +521,6 @@ describe("useMessageListController", () => {
act(() => renderer.unmount())
})
- it("minimally scrolls an overlapping selected row above the active accessory rail", () => {
- selectionRailTop = 692
- selectedRowBottom = 747.5
- let renderer: ReturnType<typeof rtlRender>
- act(() => {
- renderer = rtlRender(
- React.createElement(Probe, { value: props() })
- )
- })
-
- act(() => latest.onEnterSelectId("m1"))
- runNextFrame()
-
- expect(scrollNode.scrollTop).toBe(63.5)
- selectedRowBottom = 684
- runNextFrame()
- selectionRailTop = null
- runNextFrame()
- act(() => renderer!.unmount())
- })
-
- it("minimally scrolls a selected row when its non-overlapping rail gap is under 8px", () => {
- selectionRailTop = 692
- selectedRowBottom = 688
- let renderer: ReturnType<typeof rtlRender>
- act(() => {
- renderer = rtlRender(
- React.createElement(Probe, { value: props() })
- )
- })
-
- act(() => latest.onEnterSelectId("m1"))
- runNextFrame()
-
- expect(scrollNode.scrollTop).toBe(4)
- selectedRowBottom = 684
- runNextFrame()
- expect(scrollNode.scrollTop).toBe(4)
- runNextFrame()
- expect(frameCallbacks.size).toBe(0)
- act(() => renderer!.unmount())
- })
-
- it("rechecks selected-row clearance when the composer moves the rail", () => {
- selectionRailTop = 692
- selectedRowBottom = 684
- let renderer: ReturnType<typeof rtlRender>
- act(() => {
- renderer = rtlRender(
- React.createElement(Probe, { value: props({ composerOverlap: 0 }) })
- )
- })
-
- act(() => latest.onEnterSelectId("m1"))
- runNextFrame()
- runNextFrame()
- expect(scrollNode.scrollTop).toBe(0)
-
- selectionRailTop = 596
- act(() => {
- renderer!.rerender(
- React.createElement(Probe, { value: props({ composerOverlap: 96 }) })
- )
- })
- runNextFrame()
- expect(scrollNode.scrollTop).toBe(96)
- act(() => renderer!.unmount())
- })
-
it("closes the share dialog before exiting selection mode", () => {
const source = readWebSource(
"src/components/community/messages/message-list-controller.ts",
@@ -605,6 +535,15 @@ describe("useMessageListController", () => {
)
})
+ it("does not write scroll position for footer-owned selection controls", () => {
+ const source = readWebSource(
+ "src/components/community/messages/message-list-controller.ts",
+ )
+ expect(source).not.toContain("keepSelectionClearOfRail")
+ expect(source).not.toContain("SELECTION_RAIL_GAP_PX")
+ expect(source).not.toContain("[data-selection=\"active\"]")
+ })
+
it("consumes a loaded target after zero-height measurement and clears highlight after visibility", () => {
const consumed = vi.fn()
let renderer: ReturnType<typeof rtlRender>
diff --git a/src/web/src/components/community/messages/message-list-controller.ts b/src/web/src/components/community/messages/message-list-controller.ts
index f65753852..f103187ab 100644
--- a/src/web/src/components/community/messages/message-list-controller.ts
+++ b/src/web/src/components/community/messages/message-list-controller.ts
@@ -8,11 +8,8 @@ import { useVirtualCursorSentinel } from "@/hooks/community/use-virtual-cursor-s
import { useInitialPositionTransition } from "./initial-position-transition"
import type { ResolvedMessageListProps } from "./message-list-types"
-const SELECTION_RAIL_GAP_PX = 8
-
export function useMessageListController({
messages,
- composerOverlap,
loading,
newDividerBefore,
scrollToMessageId,
@@ -115,12 +112,15 @@ export function useMessageListController({
onImageLoad,
captureOlderPageAnchor,
isOlderPageAnchorSettling,
+ captureNewerPageAnchor,
+ isNewerPageAnchorSettling,
} = useScrollAnchor({
items,
newDividerBefore,
initialScrollReady: scrollAnchorReady,
hasMoreNewer,
isFetchingOlder,
+ isFetchingNewer,
presentVersion,
viewerUserId,
heroHeight,
@@ -133,46 +133,6 @@ export function useMessageListController({
positionSettled: anchorPositionSettled && targetPositionSettled,
})
- useLayoutEffect(() => {
- const element = scrollRef.current
- if (!element || !selectMode || selectedIds.size === 0) return
-
- let frame = 0
- let attempts = 0
- let stableFrames = 0
- const keepSelectionClearOfRail = () => {
- frame = window.requestAnimationFrame(() => {
- attempts += 1
- const rail = element.parentElement?.querySelector<HTMLElement>(
- '[data-selection="active"]',
- )
- const selectedRows = Array.from(
- element.querySelectorAll<HTMLElement>("[data-msg-id]"),
- ).filter((row) => selectedIds.has(row.dataset.msgId ?? ""))
-
- if (rail && selectedRows.length > 0) {
- const railTop = rail.getBoundingClientRect().top
- const lowestSelectedBottom = Math.max(...selectedRows.map(
- (row) => row.getBoundingClientRect().bottom,
- ))
- const gapShortfall = lowestSelectedBottom + SELECTION_RAIL_GAP_PX - railTop
- if (gapShortfall > 1) {
- element.scrollTop += gapShortfall
- stableFrames = 0
- } else {
- stableFrames += 1
- }
- } else {
- stableFrames = 0
- }
-
- if (stableFrames < 2 && attempts < 120) keepSelectionClearOfRail()
- })
- }
- keepSelectionClearOfRail()
- return () => window.cancelAnimationFrame(frame)
- }, [composerOverlap, selectMode, selectedIds, scrollRef])
-
useEffect(() => {
if (!onScrollRoot) return
onScrollRoot(scrollRef.current)
@@ -192,6 +152,8 @@ export function useMessageListController({
scrollRef,
hasMore: hasMoreNewer,
isFetching: isFetchingNewer,
+ isSettling: isNewerPageAnchorSettling,
+ onBeforeLoad: captureNewerPageAnchor,
onLoad: onLoadNewer,
edge: "end",
})
diff --git a/src/web/src/components/community/messages/message-list-facade.contract.test.ts b/src/web/src/components/community/messages/message-list-facade.contract.test.ts
index 9d05a3940..fb231fddd 100644
--- a/src/web/src/components/community/messages/message-list-facade.contract.test.ts
+++ b/src/web/src/components/community/messages/message-list-facade.contract.test.ts
@@ -14,11 +14,9 @@ vi.mock("./initial-position-aurora.module.css", () => ({
type ExpectedMessageListProps = {
channel: string
messages: Msg[]
- composerOverlap?: number
loading?: boolean
pinnedIds?: Set<string>
newDividerBefore?: string
- typingUsers?: string[]
onOpenThread: (id: string) => void
onOpenProfile?: OpenProfile
onToggleReaction?: (id: string, emoji: string) => void
@@ -68,7 +66,7 @@ describe("MessageList facade contract", () => {
const text = source("src/components/community/messages/message-list.tsx")
expect(text).toContain('variant = "channel"')
expect(text).toContain("initialScrollReady = true")
- expect(text).toContain("composerOverlap = 0")
+ expect(text).not.toContain("composerOverlap")
expect(text).toContain("useMessageListController(resolvedProps)")
expect(text).toContain("return renderMessageListView(resolvedProps, controller, () => (")
expect(text).toContain("<VirtualRows")
diff --git a/src/web/src/components/community/messages/message-list-row.dom.test.ts b/src/web/src/components/community/messages/message-list-row.dom.test.ts
index a611d0b3a..9c5d18dc3 100644
--- a/src/web/src/components/community/messages/message-list-row.dom.test.ts
+++ b/src/web/src/components/community/messages/message-list-row.dom.test.ts
@@ -46,7 +46,6 @@ const props = {
messages: [],
variant: "channel" as const,
initialScrollReady: true,
- composerOverlap: 0,
viewerUserId: "viewer_1",
pinnedIds: new Set(["m1"]),
...callbacks,
diff --git a/src/web/src/components/community/messages/message-list-types.ts b/src/web/src/components/community/messages/message-list-types.ts
index 028dc1c44..4624db101 100644
--- a/src/web/src/components/community/messages/message-list-types.ts
+++ b/src/web/src/components/community/messages/message-list-types.ts
@@ -5,11 +5,9 @@ import type { OpenProfile } from "@/components/community/social/profile-types"
export type MessageListProps = {
channel: string
messages: Msg[]
- composerOverlap?: number
loading?: boolean
pinnedIds?: Set<string>
newDividerBefore?: string
- typingUsers?: string[]
onOpenThread: (id: string) => void
onOpenProfile?: OpenProfile
onToggleReaction?: (id: string, emoji: string) => void
@@ -48,6 +46,5 @@ export type MessageListProps = {
export type ResolvedMessageListProps = MessageListProps & {
variant: "channel" | "dm"
initialScrollReady: boolean
- composerOverlap: number
hoverCapable: boolean
}
diff --git a/src/web/src/components/community/messages/message-list-view.dom.test.ts b/src/web/src/components/community/messages/message-list-view.dom.test.ts
index 0176a07a7..ed493a46b 100644
--- a/src/web/src/components/community/messages/message-list-view.dom.test.ts
+++ b/src/web/src/components/community/messages/message-list-view.dom.test.ts
@@ -9,6 +9,23 @@ import type { ResolvedMessageListProps } from "./message-list-types"
vi.mock("./composer-accessory-rail", () => ({
ComposerAccessoryRail: vi.fn((props: Record<string, unknown>) => React.createElement("accessory-rail", props)),
+ MessageSelectionFooter: ({
+ selectedCount,
+ onCancel,
+ onShare,
+ }: {
+ selectedCount: number
+ onCancel: () => void
+ onShare: () => void
+ }) => React.createElement("div", { "data-selection": "active" },
+ React.createElement("button", {
+ "aria-label": "Cancel message selection",
+ onClick: onCancel,
+ }),
+ React.createElement("button", {
+ "aria-label": `Share ${selectedCount} selected messages as image`,
+ onClick: onShare,
+ })),
}))
vi.mock("./message-share-dialog", () => ({ MessageShareDialog: vi.fn(() => null) }))
vi.mock("@/components/ui/number-ticker", () => ({
@@ -45,11 +62,9 @@ function props(overrides: Partial<ResolvedMessageListProps> = {}): ResolvedMessa
createdAt: new Date(0).toISOString(),
}],
loading: true,
- typingUsers: ["Alice"],
onOpenThread: vi.fn(),
variant: "channel",
initialScrollReady: true,
- composerOverlap: 0,
...overrides,
}
}
@@ -86,17 +101,15 @@ function controller(overrides: Partial<MessageListController> = {}): MessageList
describe("renderMessageListView", () => {
beforeEach(() => vi.clearAllMocks())
- it("keeps warm non-empty loading data on the loaded DOM with live typing and pill", () => {
+ it("keeps warm non-empty loading data on the loaded DOM with the away pill", () => {
const listProps = props()
const state = controller()
const renderRows = vi.fn(() => React.createElement("virtual-rows"))
const renderer = render(renderMessageListView(listProps, state, renderRows))
expect(mockedRail).toHaveBeenCalledWith(expect.objectContaining({
- typingNames: ["Alice"],
scrollCount: 3,
- selectMode: false,
- composerOverlap: 0,
}), undefined)
+ expect(mockedRail.mock.calls.at(-1)?.[0]).not.toHaveProperty("composerOverlap")
const scrollerBoundary = renderer.container.querySelector("[data-message-scroller-boundary]")!
expect(scrollerBoundary.querySelectorAll("accessory-rail")).toHaveLength(1)
expect(renderer.container.querySelectorAll("[data-message-typing-space]")).toHaveLength(0)
@@ -211,47 +224,38 @@ describe("renderMessageListView", () => {
expect(renderer.container.querySelector("[data-message-positioning-skeleton]")).not.toBeInTheDocument()
})
- it("routes typing through the rail without adding a dynamic flex sibling", () => {
+ it("keeps typing ownership out of the message list", () => {
const renderer = render(renderMessageListView(
- props({ loading: false, typingUsers: [] }),
+ props({ loading: false }),
controller({ isLoading: false, pillCount: 0 }),
() => React.createElement("virtual-rows"),
))
- expect(mockedRail).toHaveBeenLastCalledWith(expect.objectContaining({ typingNames: [] }), undefined)
- expect(renderer.container.querySelectorAll("[data-message-typing-space]")).toHaveLength(0)
- renderer.rerender(renderMessageListView(
- props({ loading: false, typingUsers: ["Alice"] }),
- controller({ isLoading: false, pillCount: 0 }),
- () => React.createElement("virtual-rows"),
- ))
- expect(mockedRail).toHaveBeenLastCalledWith(expect.objectContaining({
- typingNames: ["Alice"],
- }), undefined)
+ expect(mockedRail).toHaveBeenLastCalledWith(expect.objectContaining({ scrollCount: 0 }), undefined)
expect(renderer.container.querySelectorAll("[data-message-typing-space]")).toHaveLength(0)
+ expect(JSON.stringify(mockedRail.mock.calls.at(-1)?.[0])).not.toContain("typing")
})
- it("keeps one fixed responsive tail safe area across every rail state", () => {
+ it("keeps only the normal tail inset across scroll and selection state", () => {
const renderer = render(renderMessageListView(
- props({ typingUsers: [] }),
+ props(),
controller({ pillCount: 0 }),
() => React.createElement("virtual-rows"),
))
const content = () => renderer.container.querySelector<HTMLElement>("[data-message-list-content]")!
for (const state of [
- { typingUsers: ["Alice"], pillCount: 0, selectMode: false },
- { typingUsers: [], pillCount: 2, selectMode: false },
- { typingUsers: ["Alice"], pillCount: 2, selectMode: false },
- { typingUsers: ["Alice"], pillCount: 0, selectMode: true },
+ { pillCount: 0, selectMode: false },
+ { pillCount: 2, selectMode: false },
+ { pillCount: 0, selectMode: true },
]) {
- expect(content()).toHaveClass("pb-14", "sm:pb-18")
- expect(content()).not.toHaveClass("pb-8")
+ expect(content()).toHaveClass("pb-4", "sm:pb-6")
+ expect(content()).not.toHaveClass("pb-14", "sm:pb-18")
renderer.rerender(renderMessageListView(
- props({ typingUsers: state.typingUsers }),
+ props(),
controller({ pillCount: state.pillCount, selectMode: state.selectMode }),
() => React.createElement("virtual-rows"),
))
}
- expect(content()).toHaveClass("pb-14", "sm:pb-18")
+ expect(content()).toHaveClass("pb-4", "sm:pb-6")
})
it("wires selection actions and dialog close without changing overlay order", () => {
@@ -267,19 +271,25 @@ describe("renderMessageListView", () => {
setShareOpen,
closeShare,
})
+ const footerSlot = document.createElement("div")
+ document.body.appendChild(footerSlot)
const renderer = render(renderMessageListView(
props(),
state,
() => React.createElement("virtual-rows"),
+ footerSlot,
))
- const railProps = mockedRail.mock.calls.at(-1)![0]
- expect(railProps).toMatchObject({
- selectMode: true,
- selectedCount: 1,
- })
- railProps.onCancelSelection()
+ expect(mockedRail).not.toHaveBeenCalled()
+ expect(footerSlot.querySelector("[data-selection='active']")).not.toBeNull()
+ const cancel = footerSlot.querySelector<HTMLButtonElement>(
+ '[aria-label="Cancel message selection"]',
+ )!
+ const share = footerSlot.querySelector<HTMLButtonElement>(
+ '[aria-label="Share 1 selected messages as image"]',
+ )!
+ cancel.click()
expect(exitSelect).toHaveBeenCalledOnce()
- railProps.onShareSelection()
+ share.click()
expect(setShareOpen).toHaveBeenCalledWith(true)
expect(mockedShareDialog).toHaveBeenCalledWith(expect.objectContaining({
m: state.selectedMessages,
@@ -288,7 +298,8 @@ describe("renderMessageListView", () => {
}), undefined)
mockedShareDialog.mock.calls.at(-1)![0].onClose()
expect(closeShare).toHaveBeenCalledOnce()
- expect(renderer.container.querySelectorAll("accessory-rail")).toHaveLength(1)
+ expect(renderer.container.querySelectorAll("accessory-rail")).toHaveLength(0)
+ footerSlot.remove()
})
it("keeps both sentinels and the direct rows callback in the exact loaded DOM positions", () => {
@@ -323,7 +334,7 @@ describe("renderMessageListView", () => {
expect(renderer.getByText("Loading newer messages…")).toBeInTheDocument()
const content = renderer.container.querySelector<HTMLElement>("[data-message-list-content]")!
- expect(content).toHaveClass("pb-14", "sm:pb-18")
+ expect(content).toHaveClass("pb-4", "sm:pb-6")
const elementChildren = Array.from(content.children)
expect(elementChildren).toHaveLength(3)
expect(elementChildren[0]).toHaveClass("mb-6")
diff --git a/src/web/src/components/community/messages/message-list-view.tsx b/src/web/src/components/community/messages/message-list-view.tsx
index 0e5bf147b..e235cda7c 100644
--- a/src/web/src/components/community/messages/message-list-view.tsx
+++ b/src/web/src/components/community/messages/message-list-view.tsx
@@ -1,8 +1,9 @@
import type { ReactNode } from "react"
+import { createPortal } from "react-dom"
import { Skeleton } from "@/components/ui/skeleton"
import { tid } from "@/lib/community/testids"
import { ChannelIcon } from "../channels/channel-icon"
-import { ComposerAccessoryRail } from "./composer-accessory-rail"
+import { ComposerAccessoryRail, MessageSelectionFooter } from "./composer-accessory-rail"
import { InitialPositionAurora } from "./initial-position-aurora"
import { MessageShareDialog } from "./message-share-dialog"
import type { MessageListController } from "./message-list-controller"
@@ -12,9 +13,18 @@ export function renderMessageListView(
props: ResolvedMessageListProps,
controller: MessageListController,
renderRows: () => ReactNode,
+ footerSlot: HTMLDivElement | null = null,
) {
return (
<div className="relative flex min-h-0 flex-1 flex-col">
+ {controller.selectMode && footerSlot && createPortal(
+ <MessageSelectionFooter
+ selectedCount={controller.selectedIds.size}
+ onCancel={controller.exitSelect}
+ onShare={() => controller.setShareOpen(true)}
+ />,
+ footerSlot,
+ )}
{controller.shareOpen && controller.selectedMessages.length > 0 && (
<MessageShareDialog
m={controller.selectedMessages}
@@ -23,17 +33,11 @@ export function renderMessageListView(
/>
)}
<div data-message-scroller-boundary className="relative isolate min-h-0 flex-1">
- {controller.initialPosition.contentInteractive && (
+ {controller.initialPosition.contentInteractive && !controller.selectMode && (
<ComposerAccessoryRail
- typingNames={props.typingUsers ?? []}
scrollCount={controller.pillCount}
scrollMode={controller.pillMode}
onScroll={controller.pillOnClick}
- selectMode={controller.selectMode}
- selectedCount={controller.selectedIds.size}
- onCancelSelection={controller.exitSelect}
- onShareSelection={() => controller.setShareOpen(true)}
- composerOverlap={props.composerOverlap}
/>
)}
<div
@@ -46,7 +50,7 @@ export function renderMessageListView(
data-initial-position-phase={controller.initialPosition.phase}
aria-hidden={!controller.initialPosition.showSkeleton && !controller.initialPosition.contentVisible}
inert={!controller.initialPosition.showSkeleton && !controller.initialPosition.contentInteractive}
- className={`flex min-h-full flex-col justify-end px-4 pb-14 pt-8 sm:pb-18 ${
+ className={`flex min-h-full flex-col justify-end px-4 pb-4 pt-8 sm:pb-6 ${
controller.initialPosition.phase === "revealing"
? "opacity-100 transition-opacity duration-300 ease-linear motion-reduce:transition-opacity"
: controller.initialPosition.showSkeleton || controller.initialPosition.contentVisible
@@ -107,7 +111,7 @@ export function renderMessageListView(
: "opacity-100"
}`}
>
- <div className="flex min-h-full flex-col justify-end px-4 pb-14 pt-8 sm:pb-18">
+ <div className="flex min-h-full flex-col justify-end px-4 pb-4 pt-8 sm:pb-6">
<MessageListSkeletonContent variant={props.variant} />
</div>
</div>
@@ -132,7 +136,7 @@ export function MessageListSkeleton({ variant = "channel" }: { variant?: "channe
>
<div
data-message-list-content
- className="flex min-h-full flex-col justify-end px-4 pb-14 pt-8 sm:pb-18"
+ className="flex min-h-full flex-col justify-end px-4 pb-4 pt-8 sm:pb-6"
>
<MessageListSkeletonContent variant={variant} />
</div>
diff --git a/src/web/src/components/community/messages/message-list.tsx b/src/web/src/components/community/messages/message-list.tsx
index 463704163..49f1fe1f0 100644
--- a/src/web/src/components/community/messages/message-list.tsx
+++ b/src/web/src/components/community/messages/message-list.tsx
@@ -1,7 +1,9 @@
"use client"
+import { useLayoutEffect } from "react"
import { useMessageListController } from "./message-list-controller"
import { useHoverCapable } from "@/hooks/use-hover-capable"
+import { useConversationFooterSlot } from "./conversation-footer-shell"
import type { MessageListProps, ResolvedMessageListProps } from "./message-list-types"
import { renderMessageListRow } from "./message-list-row"
import { renderMessageListView } from "./message-list-view"
@@ -10,18 +12,22 @@ import { VirtualRows } from "./virtual-cursor-list"
export function MessageList({
variant = "channel",
initialScrollReady = true,
- composerOverlap = 0,
...props
}: MessageListProps) {
const hoverCapable = useHoverCapable()
const resolvedProps: ResolvedMessageListProps = {
...props,
- composerOverlap,
variant,
initialScrollReady,
hoverCapable,
}
const controller = useMessageListController(resolvedProps)
+ const footerSlot = useConversationFooterSlot()
+ const setSelectionActive = footerSlot?.setSelectionActive
+ useLayoutEffect(() => {
+ setSelectionActive?.(controller.selectMode)
+ return () => setSelectionActive?.(false)
+ }, [controller.selectMode, setSelectionActive])
return renderMessageListView(resolvedProps, controller, () => (
<VirtualRows
items={controller.items}
@@ -29,5 +35,5 @@ export function MessageList({
itemKey={(item) => item.key}
renderItem={(item) => renderMessageListRow(item, resolvedProps, controller)}
/>
- ))
+ ), footerSlot?.target ?? null)
}
diff --git a/src/web/src/components/community/messages/message.render.dom.test.ts b/src/web/src/components/community/messages/message.render.dom.test.ts
index c07d7928c..5a67dbe0b 100644
--- a/src/web/src/components/community/messages/message.render.dom.test.ts
+++ b/src/web/src/components/community/messages/message.render.dom.test.ts
@@ -357,6 +357,33 @@ afterEach(() => {
})
describe("Message memo comparator", () => {
+ it("keeps selection controls out of the message row layout", () => {
+ let renderer: DomRenderer
+ act(() => {
+ renderer = render(makeTree({
+ m: baseMsg({ content: "a long selectable message ".repeat(20) }),
+ onOpenThread: vi.fn(),
+ selectMode: true,
+ selected: false,
+ onToggleSelect: vi.fn(),
+ }), { createNodeMock: () => genericMock })
+ })
+
+ const row = renderer!.root.find((node) => (
+ typeof node.props.className === "string"
+ && node.props.className.includes("group relative -mx-2")
+ ))
+ const checkbox = renderer!.root.find((node) => (
+ typeof node.props.className === "string"
+ && node.props.className.includes("absolute left-5 top-1/2")
+ ))
+
+ expect(row.props.className).toContain("cursor-pointer")
+ expect(row.props.className).not.toContain("pl-9")
+ expect(checkbox.parent?.element).toBe(row.element)
+ act(() => renderer!.unmount())
+ })
+
it("keeps the strict Unknown fallback for unresolved live authors", () => {
let renderer: DomRenderer
act(() => {
diff --git a/src/web/src/components/community/messages/message.tsx b/src/web/src/components/community/messages/message.tsx
index d97f49d6e..72cc33238 100644
--- a/src/web/src/components/community/messages/message.tsx
+++ b/src/web/src/components/community/messages/message.tsx
@@ -396,7 +396,7 @@ function MessageImpl({
swipeReplyEnabled ? "z-10 touch-pan-y bg-background" : "",
swipeVisual.active ? "transition-none" : "transition-transform duration-150 ease-out",
m.grouped ? "py-0" : "mt-3 pt-1.5 pb-0",
- selectable ? "cursor-pointer pl-9" : "",
+ selectable ? "cursor-pointer" : "",
selected ? "bg-primary/10" : highlighted ? "bg-primary/10" : selectable ? "hover:bg-accent/40" : "hover:bg-accent/40",
].join(" ")}
style={swipeVisual.offset > 0
@@ -594,7 +594,7 @@ function MessageImpl({
<span
aria-hidden
className={[
- "absolute left-1.5 top-1/2 z-20 grid size-4 -translate-y-1/2 place-items-center rounded-[5px] border transition-colors",
+ "absolute left-5 top-1/2 z-20 grid size-4 -translate-y-1/2 place-items-center rounded-[5px] border transition-colors",
selected ? "border-primary bg-primary text-primary-foreground" : "border-muted-foreground/50 bg-card",
].join(" ")}
>
diff --git a/src/web/src/components/community/messages/typing-indicator.dom.test.ts b/src/web/src/components/community/messages/typing-indicator.dom.test.ts
index 769abf346..8d81a56db 100644
--- a/src/web/src/components/community/messages/typing-indicator.dom.test.ts
+++ b/src/web/src/components/community/messages/typing-indicator.dom.test.ts
@@ -28,4 +28,16 @@ describe("TypingIndicator", () => {
expect(status).toHaveTextContent("4 people are typing…")
expect(status).not.toHaveTextContent("Dorothy")
})
+
+ it("uses a compact header status without a floating pill footprint", () => {
+ render(createElement(TypingIndicator, {
+ names: ["Alice"],
+ variant: "header",
+ }))
+
+ const status = screen.getByTestId(tid.typingIndicator)
+ expect(status).toHaveClass("h-7", "max-w-[min(16rem,40vw)]")
+ expect(status).not.toHaveClass("h-8", "rounded-full", "shadow-(--e1)")
+ expect(status.querySelector(".min-w-0.truncate")).toHaveClass("hidden", "sm:inline")
+ })
})
diff --git a/src/web/src/components/community/messages/typing-indicator.tsx b/src/web/src/components/community/messages/typing-indicator.tsx
index 6759451b8..43005e318 100644
--- a/src/web/src/components/community/messages/typing-indicator.tsx
+++ b/src/web/src/components/community/messages/typing-indicator.tsx
@@ -1,7 +1,15 @@
import { tid } from "@/lib/community/testids"
import { cn } from "@/lib/utils"
-export function TypingIndicator({ names, className }: { names: string[]; className?: string }) {
+export function TypingIndicator({
+ names,
+ className,
+ variant = "pill",
+}: {
+ names: string[]
+ className?: string
+ variant?: "pill" | "header"
+}) {
if (names.length === 0) return null
const label = names.length === 0
? null
@@ -17,7 +25,10 @@ export function TypingIndicator({ names, className }: { names: string[]; classNa
aria-live="polite"
aria-atomic="true"
className={cn(
- "pointer-events-none flex h-8 min-w-0 max-w-full items-center gap-2 rounded-full border border-border bg-background/90 px-3 text-xs text-muted-foreground shadow-(--e1) backdrop-blur-sm",
+ "pointer-events-none flex min-w-0 max-w-full items-center gap-2 text-xs text-muted-foreground",
+ variant === "pill"
+ ? "h-8 rounded-full border border-border bg-background/90 px-3 shadow-(--e1) backdrop-blur-sm"
+ : "h-7 max-w-[min(16rem,40vw)] shrink px-1.5",
className,
)}
>
@@ -26,7 +37,9 @@ export function TypingIndicator({ names, className }: { names: string[]; classNa
<span className="size-1.5 rounded-full bg-muted-foreground motion-safe:animate-[typing-dot_1.4s_ease-in-out_160ms_infinite]" />
<span className="size-1.5 rounded-full bg-muted-foreground motion-safe:animate-[typing-dot_1.4s_ease-in-out_320ms_infinite]" />
</span>
- <span className="min-w-0 truncate">{label}</span>
+ <span className={cn("min-w-0 truncate", variant === "header" && "hidden sm:inline")}>
+ {label}
+ </span>
</div>
)
}
diff --git a/src/web/src/hooks/community/use-channel-read-state.test.ts b/src/web/src/hooks/community/use-channel-read-state.test.ts
index 8a5c39db8..fa18ae73d 100644
--- a/src/web/src/hooks/community/use-channel-read-state.test.ts
+++ b/src/web/src/hooks/community/use-channel-read-state.test.ts
@@ -97,6 +97,39 @@ describe("useChannelReadStateSnapshot — freeze invariant", () => {
})
})
+ it("withholds a retained cache value until the mount refetch settles", async () => {
+ const useHook = await loadHook()
+ queryReturn = {
+ data: {
+ lastReadMessageId: "m_retained",
+ lastReadAt: "2026-07-01T00:00:00.000Z",
+ lastReadSeq: 10,
+ },
+ isFetching: true,
+ }
+ const pending = useHook("ch_1")
+ flushEffects()
+ expect(pending.snapshot).toBeNull()
+
+ refCounter = 0
+ pendingEffects = []
+ queryReturn = {
+ data: {
+ lastReadMessageId: "m_fresh",
+ lastReadAt: "2026-07-02T00:00:00.000Z",
+ lastReadSeq: 20,
+ },
+ isFetching: false,
+ }
+ const settled = useHook("ch_1")
+ flushEffects()
+ expect(settled.snapshot).toEqual({
+ lastReadMessageId: "m_fresh",
+ lastReadAt: "2026-07-02T00:00:00.000Z",
+ lastReadSeq: 20,
+ })
+ })
+
it("freezes the snapshot — a subsequent 'refetch' with a NEW value must NOT change what the hook returns", async () => {
const useHook = await loadHook()
diff --git a/src/web/src/hooks/community/use-channel-read-state.ts b/src/web/src/hooks/community/use-channel-read-state.ts
index 6c6308912..b6a9d8000 100644
--- a/src/web/src/hooks/community/use-channel-read-state.ts
+++ b/src/web/src/hooks/community/use-channel-read-state.ts
@@ -30,18 +30,16 @@ export type ChannelReadStateSnapshot = {
* once and never update it during the mount, even if TanStack refetches or
* a WS event mutates the underlying row.
*
- * Implementation: fire a normal `useQuery`, then latch the first non-null
- * response in a `useRef`. All subsequent calls return the ref value. The
- * `staleTime: Infinity` + `snapshotRef` combo keeps the anchor frozen for
- * the entire mount regardless of what TanStack does mid-mount.
+ * Implementation: force a mount fetch, then latch its first settled non-null
+ * response in a `useRef`. Cached data retained across an unmount is withheld
+ * while that fetch is active; otherwise it could become the new mount's
+ * frozen anchor before the server response arrives. All later calls return
+ * the ref value, keeping the anchor stable through mid-mount refetches.
*
- * Cross-mount refresh: `gcTime: 0` evicts the cache entry the instant the
- * consumer unmounts. The next mount finds an empty cache and MUST refetch
- * from the server — otherwise the divider re-anchors to the pre-scroll
- * position even after the IntersectionObserver has advanced the read row.
- * Note: `refetchOnMount: true` is NOT enough here — with `staleTime:
- * Infinity`, TanStack considers cached data fresh and skips the refetch.
- * `gcTime: 0` is the only reliable path to a genuine cross-mount reload.
+ * Cross-mount refresh: `gcTime: 0` normally evicts the cache entry after the
+ * consumer unmounts, and `refetchOnMount: "always"` covers a quick remount
+ * before that eviction timer runs. The next snapshot therefore comes from
+ * the current server response rather than the pre-scroll pointer.
*/
export function useChannelReadStateSnapshot(channelId: string | null | undefined): {
snapshot: ChannelReadStateSnapshot | null
@@ -59,19 +57,13 @@ export function useChannelReadStateSnapshot(channelId: string | null | undefined
},
enabled: !!channelId,
staleTime: Infinity,
- // Evict the cache entry the moment the last observer unmounts. Combined
- // with the fresh useRef on each mount, this guarantees revisiting a
- // channel fires a real network fetch instead of replaying the stale
- // pre-scroll pointer — otherwise the "New" divider re-appears at the
- // old position because TanStack's `staleTime: Infinity` treats cached
- // data as fresh and refuses to refetch on remount.
+ // Schedule eviction when the last observer unmounts. A rapid remount can
+ // still beat that timer, so the forced refetch and settled-data latch are
+ // both required for a current read pointer.
gcTime: 0,
- // Belt-and-braces alongside `gcTime: 0`. If a persisted or hydrated
- // snapshot ever lands in the cache (e.g. a future feature flips this
- // key back into the persist allowlist), `refetchOnMount: "always"` still
- // fires a network fetch on mount. The `snapshotRef` below latches only
- // the FIRST non-null resolution, so the refetched value is what gets
- // frozen — the freeze semantics are preserved.
+ // A retained or hydrated cache entry must not become the frozen snapshot
+ // for this mount. Always refetch; the latch below ignores query data until
+ // that request settles.
refetchOnMount: "always",
refetchOnWindowFocus: false,
refetchOnReconnect: false,
@@ -94,12 +86,13 @@ export function useChannelReadStateSnapshot(channelId: string | null | undefined
/* eslint-enable react-hooks/refs */
useEffect(() => {
if (snapshotRef.current !== null) return
+ if (query.isFetching) return
if (query.data) snapshotRef.current = query.data
- }, [query.data])
+ }, [query.data, query.isFetching])
/* eslint-disable react-hooks/refs -- latched snapshot read; see hook tests */
return {
- snapshot: snapshotRef.current ?? (query.data ?? null),
+ snapshot: snapshotRef.current ?? (!query.isFetching ? (query.data ?? null) : null),
isFetching: query.isFetching,
}
/* eslint-enable react-hooks/refs */
diff --git a/src/web/src/hooks/community/use-dm-read-state.test.ts b/src/web/src/hooks/community/use-dm-read-state.test.ts
index e24133868..0727f49ba 100644
--- a/src/web/src/hooks/community/use-dm-read-state.test.ts
+++ b/src/web/src/hooks/community/use-dm-read-state.test.ts
@@ -86,6 +86,39 @@ describe("useDmReadStateSnapshot — freeze invariant", () => {
})
})
+ it("withholds a retained cache value until the mount refetch settles", async () => {
+ const useHook = await loadHook()
+ queryReturn = {
+ data: {
+ lastReadMessageId: "m_retained",
+ lastReadAt: "2026-07-01T00:00:00.000Z",
+ lastReadSeq: 10,
+ },
+ isFetching: true,
+ }
+ const pending = useHook("dm_1")
+ flushEffects()
+ expect(pending.snapshot).toBeNull()
+
+ refCounter = 0
+ pendingEffects = []
+ queryReturn = {
+ data: {
+ lastReadMessageId: "m_fresh",
+ lastReadAt: "2026-07-02T00:00:00.000Z",
+ lastReadSeq: 20,
+ },
+ isFetching: false,
+ }
+ const settled = useHook("dm_1")
+ flushEffects()
+ expect(settled.snapshot).toEqual({
+ lastReadMessageId: "m_fresh",
+ lastReadAt: "2026-07-02T00:00:00.000Z",
+ lastReadSeq: 20,
+ })
+ })
+
it("freezes the snapshot — a subsequent 'refetch' with a NEW value must NOT change what the hook returns", async () => {
const useHook = await loadHook()
diff --git a/src/web/src/hooks/community/use-dm-read-state.ts b/src/web/src/hooks/community/use-dm-read-state.ts
index d30e4dcc2..55e4f2bb8 100644
--- a/src/web/src/hooks/community/use-dm-read-state.ts
+++ b/src/web/src/hooks/community/use-dm-read-state.ts
@@ -48,13 +48,12 @@ export function useDmReadStateSnapshot(dmId: string | null | undefined): {
},
enabled: !!dmId,
staleTime: Infinity,
- // Match the channel hook exactly — see its docstring for why `gcTime: 0`
- // is the only reliable way to force a real refetch on remount when
- // `staleTime: Infinity` treats the cached anchor as fresh forever.
+ // Match the channel hook exactly. A zero GC time normally removes the
+ // prior mount's snapshot, while the forced mount refetch below also
+ // covers a retained entry whose eviction timer has not run yet.
gcTime: 0,
- // Belt-and-braces alongside `gcTime: 0` — see channel sibling for the
- // rationale. The `snapshotRef` freeze semantics still hold because the
- // ref latches only the first non-null resolution.
+ // A retained cache value is not the new mount's snapshot. The latch below
+ // waits for this forced fetch to settle before accepting query data.
refetchOnMount: "always",
refetchOnWindowFocus: false,
refetchOnReconnect: false,
@@ -71,12 +70,13 @@ export function useDmReadStateSnapshot(dmId: string | null | undefined): {
/* eslint-enable react-hooks/refs */
useEffect(() => {
if (snapshotRef.current !== null) return
+ if (query.isFetching) return
if (query.data) snapshotRef.current = query.data
- }, [query.data])
+ }, [query.data, query.isFetching])
/* eslint-disable react-hooks/refs -- latched snapshot read; see channel hook tests */
return {
- snapshot: snapshotRef.current ?? (query.data ?? null),
+ snapshot: snapshotRef.current ?? (!query.isFetching ? (query.data ?? null) : null),
isFetching: query.isFetching,
}
/* eslint-enable react-hooks/refs */
diff --git a/src/web/src/hooks/community/use-messages.activation-refetch.dom.test.ts b/src/web/src/hooks/community/use-messages.activation-refetch.dom.test.ts
index 814d0503c..7e1c8b760 100644
--- a/src/web/src/hooks/community/use-messages.activation-refetch.dom.test.ts
+++ b/src/web/src/hooks/community/use-messages.activation-refetch.dom.test.ts
@@ -1,9 +1,16 @@
import { beforeEach, describe, expect, it, vi } from "vitest"
import React from "react"
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
+import {
+ dehydrate,
+ IsRestoringProvider,
+ QueryClient,
+ QueryClientProvider,
+} from "@tanstack/react-query"
+import { PersistQueryClientProvider } from "@tanstack/react-query-persist-client"
import { act, render } from "@/test/react-dom-harness"
import { communityKeys } from "@/lib/query-keys"
import { useDmMessages, useMessages, type MessagesPage } from "./use-messages"
+import { useDmReadStateSnapshot } from "./use-dm-read-state"
import { useMessageStreamStore } from "@/stores/community/message-stream"
const apiFetchMock = vi.fn()
@@ -48,6 +55,63 @@ function DmCapture({ lastReadMessageId, onRender }: {
return null
}
+function RevalidatingDmCapture({ lastReadMessageId, onRender }: {
+ lastReadMessageId: string | null | undefined
+ onRender: (snapshot: Snapshot) => void
+}) {
+ const result = useDmMessages("dm_activation", {
+ lastReadMessageId,
+ waitForAnchor: true,
+ reconcileLateAnchor: true,
+ revalidateOnMount: true,
+ })
+ onRender({
+ anchorReconciled: result.anchorReconciled,
+ hasMoreNewer: result.hasMoreNewer,
+ ids: result.messages.map((message) => message.id),
+ isFetching: result.isFetching,
+ })
+ return null
+}
+
+function DisabledDmRefetchProbe() {
+ const { refetch } = useDmMessages("dm_activation", {
+ lastReadMessageId: undefined,
+ waitForAnchor: true,
+ revalidateOnMount: true,
+ })
+ const requested = React.useRef(false)
+ React.useLayoutEffect(() => {
+ if (requested.current) return
+ requested.current = true
+ void refetch()
+ }, [refetch])
+ return null
+}
+
+function DmRouteCapture({ onRender }: {
+ onRender: (snapshot: Snapshot & { readStateFetching: boolean }) => void
+}) {
+ const { snapshot, isFetching: readStateFetching } = useDmReadStateSnapshot("dm_activation")
+ const result = useDmMessages("dm_activation", {
+ lastReadMessageId: readStateFetching
+ ? undefined
+ : (snapshot?.lastReadMessageId ?? null),
+ waitForAnchor: true,
+ reconcileLateAnchor: true,
+ revalidateOnMount: true,
+ viewerUserId: "viewer_1",
+ })
+ onRender({
+ anchorReconciled: result.anchorReconciled,
+ hasMoreNewer: result.hasMoreNewer,
+ ids: result.messages.map((message) => message.id),
+ isFetching: result.isFetching,
+ readStateFetching,
+ })
+ return null
+}
+
function ChannelCapture({ lastReadMessageId, onRender }: {
lastReadMessageId: string | null | undefined
onRender: (snapshot: Snapshot) => void
@@ -62,6 +126,109 @@ function ChannelCapture({ lastReadMessageId, onRender }: {
return null
}
+function PaginatingChannelCapture({ lastReadMessageId, onRender }: {
+ lastReadMessageId: string | null | undefined
+ onRender: (snapshot: Snapshot, fetchOlder: () => void) => void
+}) {
+ const result = useMessages("ch_activation", {
+ serverId: "server_1",
+ lastReadMessageId,
+ revalidateOnMount: true,
+ })
+ onRender({
+ anchorReconciled: result.anchorReconciled,
+ hasMoreNewer: result.hasMoreNewer,
+ ids: result.messages.map((message) => message.id),
+ isFetching: result.isFetching,
+ }, result.fetchOlder)
+ return null
+}
+
+function RefetchingPaginationCapture({ onRender }: {
+ onRender: (
+ snapshot: Snapshot,
+ refetch: () => Promise<unknown>,
+ fetchOlder: () => void,
+ ) => void
+}) {
+ const result = useMessages("ch_activation", {
+ serverId: "server_1",
+ lastReadMessageId: "m_anchor",
+ revalidateOnMount: false,
+ })
+ onRender({
+ anchorReconciled: result.anchorReconciled,
+ hasMoreNewer: result.hasMoreNewer,
+ ids: result.messages.map((message) => message.id),
+ isFetching: result.isFetching,
+ }, result.refetch, result.fetchOlder)
+ return null
+}
+
+function DynamicPaginationCapture({ channelId, onRender }: {
+ channelId: string | null
+ onRender: (fetchOlder: () => void) => void
+}) {
+ const result = useMessages(channelId, {
+ serverId: "server_1",
+ lastReadMessageId: channelId ? `m_anchor_${channelId}` : undefined,
+ revalidateOnMount: false,
+ })
+ onRender(result.fetchOlder)
+ return null
+}
+
+function LayoutPaginatingChannelCapture({ lastReadMessageId, onRender }: {
+ lastReadMessageId: string
+ onRender: (snapshot: Snapshot) => void
+}) {
+ const result = useMessages("ch_activation", {
+ serverId: "server_1",
+ lastReadMessageId,
+ revalidateOnMount: true,
+ })
+ const fetchOlder = result.fetchOlder
+ const requested = React.useRef(false)
+ React.useLayoutEffect(() => {
+ if (requested.current) return
+ requested.current = true
+ fetchOlder()
+ }, [fetchOlder])
+ onRender({
+ anchorReconciled: result.anchorReconciled,
+ hasMoreNewer: result.hasMoreNewer,
+ ids: result.messages.map((message) => message.id),
+ isFetching: result.isFetching,
+ })
+ return null
+}
+
+function SwitchingLayoutPaginationCapture({ channelId, queueOlder, onRender }: {
+ channelId: string
+ queueOlder: boolean
+ onRender: (snapshot: Snapshot) => void
+}) {
+ const result = useMessages(channelId, {
+ serverId: "server_1",
+ lastReadMessageId: `m_anchor_${channelId}`,
+ revalidateOnMount: queueOlder,
+ })
+ const fetchOlder = result.fetchOlder
+ const queuedFor = React.useRef<string | null>(null)
+ React.useLayoutEffect(() => {
+ if (!queueOlder || queuedFor.current === channelId) return
+ queuedFor.current = channelId
+ fetchOlder()
+ }, [channelId, fetchOlder, queueOlder])
+ onRender({
+ anchorReconciled: result.anchorReconciled,
+ hasMoreNewer: result.hasMoreNewer,
+ ids: result.messages.map((message) => message.id),
+ isFetching: result.isFetching,
+ })
+ return null
+}
+
function IndependentChannelCapture({ lastReadMessageId, onRender }: {
lastReadMessageId: string | null | undefined
onRender: (snapshot: Snapshot) => void
@@ -125,6 +292,514 @@ beforeEach(() => {
})
describe("useMessagesInner — disabled-to-enabled cache revalidation", () => {
+ it("keeps the real transport installed while the anchor gate is disabled", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ apiFetchMock.mockResolvedValue({
+ messages: [],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 0,
+ } satisfies MessagesPage)
+
+ const renderer = renderCapture(
+ queryClient,
+ React.createElement(DisabledDmRefetchProbe),
+ )
+
+ await waitFor(() => apiFetchMock.mock.calls.some(
+ ([url]) => url === "/api/community/channels/dm_activation/messages",
+ ))
+ renderer.unmount()
+ })
+
+ it("uses the refreshed anchor when retained DM messages and read-state mount together", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ const queryKey = communityKeys.dmMessages("dm_activation")
+ const cachedPage = {
+ messages: [
+ { id: "m_retained", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" },
+ { id: "m_fresh", seq: 2, createdAt: "2026-08-09T00:00:01.000Z" },
+ ],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 2,
+ } satisfies MessagesPage
+ queryClient.setQueryData(
+ queryKey,
+ {
+ pages: [cachedPage],
+ pageParams: [{ mode: "anchor", anchor: "m_retained" }],
+ },
+ { updatedAt: Date.now() },
+ )
+ queryClient.setQueryData(
+ communityKeys.dmReadStateSnapshot("dm_activation"),
+ {
+ lastReadMessageId: "m_retained",
+ lastReadAt: "2026-08-09T00:00:00.000Z",
+ lastReadSeq: 1,
+ },
+ { updatedAt: Date.now() },
+ )
+ const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries")
+ const readStateResponse = deferred<{
+ lastReadMessageId: string
+ lastReadAt: string
+ lastReadSeq: number
+ }>()
+ apiFetchMock.mockImplementation((url: string) => {
+ if (url.endsWith("/read-state")) return readStateResponse.promise
+ return Promise.resolve({
+ messages: [{ id: "m_fresh", seq: 2, createdAt: "2026-08-09T00:00:01.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 2,
+ } satisfies MessagesPage)
+ })
+ const snapshots: Array<Snapshot & { readStateFetching: boolean }> = []
+ const renderer = renderCapture(
+ queryClient,
+ React.createElement(DmRouteCapture, {
+ onRender: (snapshot) => { snapshots.push(snapshot) },
+ }),
+ )
+
+ expect(snapshots.at(-1)?.ids).toEqual(["m_retained", "m_fresh"])
+ expect(snapshots.at(-1)?.readStateFetching).toBe(true)
+ expect(apiFetchMock.mock.calls.map(([url]) => url)).toEqual([
+ "/api/community/channels/dm_activation/read-state",
+ ])
+
+ readStateResponse.resolve({
+ lastReadMessageId: "m_fresh",
+ lastReadAt: "2026-08-09T00:00:01.000Z",
+ lastReadSeq: 2,
+ })
+ await waitFor(() => apiFetchMock.mock.calls.filter(
+ ([url]) => url.includes("/messages"),
+ ).length === 1)
+ await waitFor(() => snapshots.at(-1)?.anchorReconciled === true)
+
+ expect(apiFetchMock).toHaveBeenLastCalledWith(
+ "/api/community/channels/dm_activation/messages?anchor=m_fresh",
+ { signal: expect.any(AbortSignal) },
+ )
+ expect(invalidateQueries).not.toHaveBeenCalled()
+ expect(snapshots.every((snapshot) => snapshot.ids.length > 0)).toBe(true)
+ renderer.unmount()
+ })
+
+ it("revalidates a restored DM cache after read-state becomes ready", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ const queryKey = communityKeys.dmMessages("dm_activation")
+ const cachedPage = {
+ messages: [{ id: "m_anchor", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 1,
+ } satisfies MessagesPage
+ queryClient.setQueryData(
+ queryKey,
+ {
+ pages: [cachedPage],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor" }],
+ },
+ { updatedAt: Date.now() - 60_000 },
+ )
+ const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries")
+ const readStateResponse = deferred<{
+ lastReadMessageId: string
+ lastReadAt: string
+ lastReadSeq: number
+ }>()
+ const messageSignals: AbortSignal[] = []
+ apiFetchMock.mockImplementation((url: string, init?: { signal?: AbortSignal }) => {
+ if (url.endsWith("/read-state")) return readStateResponse.promise
+ const signal = init?.signal
+ if (!signal) throw new Error("messages request requires an abort signal")
+ messageSignals.push(signal)
+ return new Promise<MessagesPage>((_resolve, reject) => {
+ const abort = () => reject(new DOMException("Aborted", "AbortError"))
+ if (signal.aborted) abort()
+ else signal.addEventListener("abort", abort, { once: true })
+ })
+ })
+ const snapshots: Array<Snapshot & { readStateFetching: boolean }> = []
+ const onRender = (snapshot: Snapshot & { readStateFetching: boolean }) => {
+ snapshots.push(snapshot)
+ }
+ const view = (isRestoring: boolean) => (
+ React.createElement(
+ QueryClientProvider,
+ { client: queryClient },
+ React.createElement(
+ IsRestoringProvider,
+ { value: isRestoring },
+ React.createElement(DmRouteCapture, { onRender }),
+ ),
+ )
+ )
+
+ const renderer = render(view(true))
+ expect(snapshots.at(-1)?.ids).toEqual(["m_anchor"])
+ expect(apiFetchMock).not.toHaveBeenCalled()
+
+ act(() => { renderer.rerender(view(false)) })
+ await waitFor(() => apiFetchMock.mock.calls.some(
+ ([url]) => url === "/api/community/channels/dm_activation/read-state",
+ ))
+ expect(messageSignals).toHaveLength(0)
+ expect(snapshots.at(-1)?.ids).toEqual(["m_anchor"])
+
+ readStateResponse.resolve({
+ lastReadMessageId: "m_anchor",
+ lastReadAt: "2026-08-09T00:00:00.000Z",
+ lastReadSeq: 1,
+ })
+ await waitFor(() => apiFetchMock.mock.calls.filter(
+ ([url]) => url.includes("/messages"),
+ ).length === 1)
+ expect(apiFetchMock.mock.calls.filter(
+ ([url]) => url.includes("/messages"),
+ )).toEqual([
+ [
+ "/api/community/channels/dm_activation/messages?anchor=m_anchor",
+ { signal: expect.any(AbortSignal) },
+ ],
+ ])
+ expect(invalidateQueries).not.toHaveBeenCalled()
+ expect(snapshots.every((snapshot) => snapshot.ids.length > 0)).toBe(true)
+ renderer.unmount()
+ })
+
+ it("guarantees cached revalidation when restore and anchor resolution finish before mount", async () => {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { refetchOnMount: false, retry: false } },
+ })
+ const queryKey = communityKeys.dmMessages("dm_activation")
+ const cachedPage = {
+ messages: [{ id: "m_anchor", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 1,
+ } satisfies MessagesPage
+ queryClient.setQueryData(queryKey, {
+ pages: [cachedPage],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor" }],
+ })
+ const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries").mockResolvedValue()
+ apiFetchMock.mockResolvedValue(cachedPage)
+ const snapshots: Snapshot[] = []
+ const view = (isRestoring: boolean) => (
+ React.createElement(
+ QueryClientProvider,
+ { client: queryClient },
+ React.createElement(
+ IsRestoringProvider,
+ { value: isRestoring },
+ React.createElement(RevalidatingDmCapture, {
+ lastReadMessageId: "m_anchor",
+ onRender: (snapshot) => { snapshots.push(snapshot) },
+ }),
+ ),
+ )
+ )
+
+ const renderer = render(view(false))
+
+ await waitFor(() => apiFetchMock.mock.calls.filter(
+ ([url]) => url.includes("/messages"),
+ ).length === 1)
+ expect(invalidateQueries).not.toHaveBeenCalled()
+ expect(snapshots.every((snapshot) => snapshot.ids.length > 0)).toBe(true)
+ renderer.unmount()
+ })
+
+ it("does not fabricate cache data if normalization observes a vanished entry", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ const cachedPage = {
+ messages: [{ id: "m_anchor", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 1,
+ } satisfies MessagesPage
+ queryClient.setQueryData(communityKeys.dmMessages("dm_activation"), {
+ pages: [cachedPage],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor" }],
+ })
+ apiFetchMock.mockResolvedValue(cachedPage)
+ const setQueryData = vi.spyOn(queryClient, "setQueryData")
+ setQueryData.mockImplementationOnce(((
+ _queryKey: readonly unknown[],
+ updater: unknown,
+ ) => {
+ expect(typeof updater).toBe("function")
+ expect((updater as (current: undefined) => unknown)(undefined)).toBeUndefined()
+ return undefined
+ }) as typeof queryClient.setQueryData)
+ const snapshots: Snapshot[] = []
+ const renderer = renderCapture(
+ queryClient,
+ React.createElement(RevalidatingDmCapture, {
+ lastReadMessageId: "m_anchor",
+ onRender: (snapshot) => { snapshots.push(snapshot) },
+ }),
+ )
+
+ await waitFor(() => apiFetchMock.mock.calls.length === 1)
+ expect(apiFetchMock).toHaveBeenCalledWith(
+ "/api/community/channels/dm_activation/messages?anchor=m_anchor",
+ { signal: expect.any(AbortSignal) },
+ )
+ expect(snapshots.every((snapshot) => snapshot.ids.length > 0)).toBe(true)
+ renderer.unmount()
+ })
+
+ it("refetches the mounted observer after persisted messages hydrate before read-state", async () => {
+ const restoredClient = new QueryClient()
+ const cachedPage = {
+ messages: [{ id: "m_anchor", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 1,
+ } satisfies MessagesPage
+ restoredClient.setQueryData(communityKeys.dmMessages("dm_activation"), {
+ pages: [cachedPage],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor" }],
+ })
+
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { refetchOnMount: false, retry: false } },
+ })
+ const restore = deferred<{
+ buster: string
+ clientState: ReturnType<typeof dehydrate>
+ timestamp: number
+ }>()
+ const persister = {
+ persistClient: vi.fn(() => Promise.resolve()),
+ removeClient: vi.fn(() => Promise.resolve()),
+ restoreClient: vi.fn(() => restore.promise),
+ }
+ const readStateResponse = deferred<{
+ lastReadMessageId: string
+ lastReadAt: string
+ lastReadSeq: number
+ }>()
+ apiFetchMock.mockImplementation((url: string) => {
+ if (url.endsWith("/read-state")) return readStateResponse.promise
+ return Promise.resolve(cachedPage)
+ })
+ const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries").mockResolvedValue()
+ const snapshots: Array<Snapshot & { readStateFetching: boolean }> = []
+ const renderer = render(
+ React.createElement(
+ PersistQueryClientProvider,
+ {
+ client: queryClient,
+ persistOptions: { buster: "activation", persister },
+ },
+ React.createElement(DmRouteCapture, {
+ onRender: (snapshot) => { snapshots.push(snapshot) },
+ }),
+ ),
+ )
+
+ expect(apiFetchMock).not.toHaveBeenCalled()
+ restore.resolve({
+ buster: "activation",
+ clientState: dehydrate(restoredClient),
+ timestamp: Date.now(),
+ })
+ await waitFor(() => apiFetchMock.mock.calls.some(
+ ([url]) => url.endsWith("/read-state"),
+ ))
+ expect(snapshots.at(-1)?.ids).toEqual(["m_anchor"])
+ expect(apiFetchMock.mock.calls.filter(([url]) => url.includes("/messages"))).toHaveLength(0)
+
+ readStateResponse.resolve({
+ lastReadMessageId: "m_anchor",
+ lastReadAt: "2026-08-09T00:00:00.000Z",
+ lastReadSeq: 1,
+ })
+ await waitFor(() => apiFetchMock.mock.calls.filter(
+ ([url]) => url.includes("/messages"),
+ ).length === 1)
+
+ expect(apiFetchMock.mock.calls.filter(([url]) => url.includes("/messages"))).toEqual([
+ ["/api/community/channels/dm_activation/messages?anchor=m_anchor", {
+ signal: expect.any(AbortSignal),
+ }],
+ ])
+ expect(invalidateQueries).not.toHaveBeenCalled()
+ const hydratedAt = snapshots.findIndex((snapshot) => snapshot.ids.length > 0)
+ expect(hydratedAt).toBeGreaterThanOrEqual(0)
+ expect(snapshots.slice(hydratedAt).every((snapshot) => snapshot.ids.length > 0)).toBe(true)
+ renderer.unmount()
+ })
+
+ it("revalidates a warm DM again after an unmount and same-client remount", async () => {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { refetchOnMount: false, retry: false } },
+ })
+ const cachedPage = {
+ messages: [{ id: "m_anchor", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 1,
+ } satisfies MessagesPage
+ queryClient.setQueryData(communityKeys.dmMessages("dm_activation"), {
+ pages: [cachedPage],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor" }],
+ })
+ queryClient.setQueryData(communityKeys.dmReadStateSnapshot("dm_activation"), {
+ lastReadMessageId: "m_anchor",
+ lastReadAt: "2026-08-09T00:00:00.000Z",
+ lastReadSeq: 1,
+ })
+ apiFetchMock.mockImplementation((url: string) => url.endsWith("/read-state")
+ ? Promise.resolve({
+ lastReadMessageId: "m_anchor",
+ lastReadAt: "2026-08-09T00:00:00.000Z",
+ lastReadSeq: 1,
+ })
+ : Promise.resolve(cachedPage))
+ const snapshots: Array<Snapshot & { readStateFetching: boolean }> = []
+ const element = React.createElement(DmRouteCapture, {
+ onRender: (snapshot) => { snapshots.push(snapshot) },
+ })
+
+ const first = renderCapture(queryClient, element)
+ await waitFor(() => apiFetchMock.mock.calls.filter(
+ ([url]) => url.includes("/messages"),
+ ).length === 1)
+ await waitFor(() => snapshots.at(-1)?.isFetching === false
+ && snapshots.at(-1)?.readStateFetching === false)
+ first.unmount()
+
+ apiFetchMock.mockClear()
+ const second = renderCapture(queryClient, element)
+ await waitFor(() => apiFetchMock.mock.calls.filter(
+ ([url]) => url.includes("/messages"),
+ ).length === 1)
+ expect(apiFetchMock.mock.calls.filter(
+ ([url]) => url.includes("/messages"),
+ )).toEqual([["/api/community/channels/dm_activation/messages?anchor=m_anchor", {
+ signal: expect.any(AbortSignal),
+ }]])
+ expect(snapshots.every((snapshot) => snapshot.ids.length > 0)).toBe(true)
+ second.unmount()
+ })
+
+ it("does not duplicate a messages request that actually fetched after mount", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ const queryKey = communityKeys.dmMessages("dm_activation")
+ const cachedPage = {
+ messages: [{ id: "m_anchor", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 1,
+ } satisfies MessagesPage
+ queryClient.setQueryData(queryKey, {
+ pages: [cachedPage],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor" }],
+ })
+ const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries")
+ const readStateResponse = deferred<{
+ lastReadMessageId: string
+ lastReadAt: string
+ lastReadSeq: number
+ }>()
+ apiFetchMock.mockImplementation((url: string) => {
+ if (url.endsWith("/read-state")) return readStateResponse.promise
+ return Promise.resolve(cachedPage)
+ })
+ const snapshots: Array<Snapshot & { readStateFetching: boolean }> = []
+ const renderer = renderCapture(
+ queryClient,
+ React.createElement(DmRouteCapture, {
+ onRender: (snapshot) => { snapshots.push(snapshot) },
+ }),
+ )
+ expect(snapshots.at(-1)?.readStateFetching).toBe(true)
+
+ await act(async () => {
+ await queryClient.fetchInfiniteQuery({
+ queryKey,
+ queryFn: () => apiFetchMock(
+ "/api/community/channels/dm_activation/messages?anchor=m_anchor",
+ ) as Promise<MessagesPage>,
+ initialPageParam: { mode: "anchor", anchor: "m_anchor" },
+ getNextPageParam: () => undefined,
+ })
+ })
+ expect(apiFetchMock.mock.calls.filter(([url]) => url.includes("/messages"))).toHaveLength(1)
+
+ readStateResponse.resolve({
+ lastReadMessageId: "m_anchor",
+ lastReadAt: "2026-08-09T00:00:00.000Z",
+ lastReadSeq: 1,
+ })
+ await waitFor(() => snapshots.at(-1)?.readStateFetching === false)
+ await act(async () => { await new Promise((resolve) => setTimeout(resolve, 20)) })
+
+ expect(invalidateQueries).not.toHaveBeenCalled()
+ expect(apiFetchMock.mock.calls.filter(([url]) => url.includes("/messages"))).toHaveLength(1)
+ renderer.unmount()
+ })
+
+ it("revalidates after an anchor-gated retained-cache write advances dataUpdatedAt", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ const queryKey = communityKeys.dmMessages("dm_activation")
+ const cachedPage = {
+ messages: [{ id: "m_anchor", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 1,
+ } satisfies MessagesPage
+ queryClient.setQueryData(queryKey, {
+ pages: [cachedPage],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor" }],
+ })
+ const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries")
+ const readStateResponse = deferred<{
+ lastReadMessageId: string
+ lastReadAt: string
+ lastReadSeq: number
+ }>()
+ apiFetchMock.mockImplementation((url: string) => {
+ if (url.endsWith("/read-state")) return readStateResponse.promise
+ return Promise.resolve(cachedPage)
+ })
+ const snapshots: Array<Snapshot & { readStateFetching: boolean }> = []
+ const renderer = renderCapture(
+ queryClient,
+ React.createElement(DmRouteCapture, {
+ onRender: (snapshot) => { snapshots.push(snapshot) },
+ }),
+ )
+
+ expect(snapshots.at(-1)?.readStateFetching).toBe(true)
+ act(() => {
+ queryClient.setQueryData(queryKey, (current: unknown) => ({
+ ...(current as object),
+ }))
+ })
+
+ readStateResponse.resolve({
+ lastReadMessageId: "m_anchor",
+ lastReadAt: "2026-08-09T00:00:00.000Z",
+ lastReadSeq: 1,
+ })
+ await waitFor(() => apiFetchMock.mock.calls.filter(
+ ([url]) => url.includes("/messages"),
+ ).length === 1)
+
+ expect(invalidateQueries).not.toHaveBeenCalled()
+ expect(snapshots.every((snapshot) => snapshot.ids.length > 0)).toBe(true)
+ renderer.unmount()
+ })
+
it("starts newest messages without waiting for read-state, then repairs a late anchor", async () => {
const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
const newest = deferred<MessagesPage>()
@@ -493,4 +1168,320 @@ describe("useMessagesInner — disabled-to-enabled cache revalidation", () => {
})
renderer.unmount()
})
+
+ it("keeps the resolved anchor ahead of pagination on a retained mount", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ const key = communityKeys.channelMessages("ch_activation")
+ queryClient.setQueryData(key, {
+ pages: [{
+ messages: [{ id: "m_anchor", seq: 2, createdAt: "2026-08-09T00:00:01.000Z" }],
+ hasMoreOlder: true,
+ hasMoreNewer: false,
+ olderCursor: "persisted-cursor",
+ latestSeq: 2,
+ }],
+ pageParams: [{ mode: "older", cursor: "persisted-cursor" }],
+ })
+ const anchorResponse = deferred<MessagesPage>()
+ apiFetchMock.mockImplementation((url: string) => {
+ if (url.endsWith("?anchor=m_anchor")) return anchorResponse.promise
+ if (url.endsWith("?cursor=fresh-cursor")) {
+ return Promise.resolve({
+ messages: [{ id: "m_old", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 2,
+ } satisfies MessagesPage)
+ }
+ throw new Error(`unexpected messages URL: ${url}`)
+ })
+ const snapshots: Snapshot[] = []
+ let fetchOlder = () => {}
+ const onRender = (snapshot: Snapshot, nextFetchOlder: () => void) => {
+ snapshots.push(snapshot)
+ fetchOlder = nextFetchOlder
+ }
+ const view = (lastReadMessageId: string | undefined) => React.createElement(
+ PaginatingChannelCapture,
+ { lastReadMessageId, onRender },
+ )
+ const renderer = renderCapture(queryClient, view(undefined))
+
+ updateCapture(renderer, queryClient, view("m_anchor"))
+ await waitFor(() => apiFetchMock.mock.calls.length === 1)
+ expect(apiFetchMock.mock.calls[0]?.[0]).toBe(
+ "/api/community/channels/ch_activation/messages?anchor=m_anchor",
+ )
+ await waitFor(() => snapshots.at(-1)?.isFetching === true)
+
+ act(() => fetchOlder())
+ expect(apiFetchMock).toHaveBeenCalledTimes(1)
+ anchorResponse.resolve({
+ messages: [{ id: "m_anchor", seq: 2, createdAt: "2026-08-09T00:00:01.000Z" }],
+ hasMoreOlder: true,
+ hasMoreNewer: false,
+ olderCursor: "fresh-cursor",
+ latestSeq: 2,
+ })
+ await waitFor(() => apiFetchMock.mock.calls.length === 2)
+ expect(apiFetchMock.mock.calls[1]?.[0]).toBe(
+ "/api/community/channels/ch_activation/messages?cursor=fresh-cursor",
+ )
+ await waitFor(() => snapshots.at(-1)?.ids.includes("m_old") === true)
+ expect(snapshots.at(-1)?.ids).toEqual(["m_old", "m_anchor"])
+ renderer.unmount()
+ })
+
+ it("ignores older pagination while the anchor gate is disabled", () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ queryClient.setQueryData(communityKeys.channelMessages("ch_activation"), {
+ pages: [{
+ messages: [{ id: "m_cached", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMore: true,
+ cursor: "persisted-cursor",
+ latestSeq: 1,
+ }],
+ pageParams: [{ mode: "newest" }],
+ })
+ let fetchOlder = () => {}
+ const renderer = renderCapture(
+ queryClient,
+ React.createElement(PaginatingChannelCapture, {
+ lastReadMessageId: undefined,
+ onRender: (_snapshot, nextFetchOlder) => { fetchOlder = nextFetchOlder },
+ }),
+ )
+
+ act(() => fetchOlder())
+ expect(apiFetchMock).not.toHaveBeenCalled()
+ renderer.unmount()
+ })
+
+ it("queues older pagination behind a generic in-flight refetch", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ queryClient.setQueryData(communityKeys.channelMessages("ch_activation"), {
+ pages: [{
+ messages: [{ id: "m_anchor", seq: 2, createdAt: "2026-08-09T00:00:01.000Z" }],
+ hasMoreOlder: true,
+ hasMoreNewer: false,
+ olderCursor: "persisted-cursor",
+ latestSeq: 2,
+ }],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor" }],
+ })
+ const refetchResponse = deferred<MessagesPage>()
+ apiFetchMock.mockImplementation((url: string) => {
+ if (url.endsWith("?anchor=m_anchor")) return refetchResponse.promise
+ if (url.endsWith("?cursor=fresh-cursor")) {
+ return Promise.resolve({
+ messages: [{ id: "m_old", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 2,
+ } satisfies MessagesPage)
+ }
+ throw new Error(`unexpected messages URL: ${url}`)
+ })
+ const snapshots: Snapshot[] = []
+ let refetch = () => Promise.resolve()
+ let fetchOlder = () => {}
+ const renderer = renderCapture(
+ queryClient,
+ React.createElement(RefetchingPaginationCapture, {
+ onRender: (snapshot, nextRefetch, nextFetchOlder) => {
+ snapshots.push(snapshot)
+ refetch = nextRefetch
+ fetchOlder = nextFetchOlder
+ },
+ }),
+ )
+
+ act(() => { void refetch() })
+ await waitFor(() => snapshots.at(-1)?.isFetching === true)
+ expect(apiFetchMock).toHaveBeenCalledTimes(1)
+ act(() => fetchOlder())
+ expect(apiFetchMock).toHaveBeenCalledTimes(1)
+
+ refetchResponse.resolve({
+ messages: [{ id: "m_anchor", seq: 2, createdAt: "2026-08-09T00:00:01.000Z" }],
+ hasMoreOlder: true,
+ hasMoreNewer: false,
+ olderCursor: "fresh-cursor",
+ latestSeq: 2,
+ })
+ await waitFor(() => apiFetchMock.mock.calls.length === 2)
+ expect(apiFetchMock.mock.calls[1]?.[0]).toBe(
+ "/api/community/channels/ch_activation/messages?cursor=fresh-cursor",
+ )
+ await waitFor(() => snapshots.at(-1)?.ids.includes("m_old") === true)
+ expect(snapshots.at(-1)?.ids).toEqual(["m_old", "m_anchor"])
+ expect(apiFetchMock.mock.calls.some(
+ ([url]) => url.includes("cursor=persisted-cursor"),
+ )).toBe(false)
+ renderer.unmount()
+ })
+
+ it("ignores an old view's pagination callback after the conversation changes", () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ queryClient.setQueryData(communityKeys.channelMessages("ch_a"), {
+ pages: [{
+ messages: [{ id: "m_anchor_ch_a", seq: 2, createdAt: "2026-08-09T00:00:01.000Z" }],
+ hasMoreOlder: true,
+ hasMoreNewer: false,
+ olderCursor: "persisted-cursor-a",
+ latestSeq: 2,
+ }],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor_ch_a" }],
+ })
+ apiFetchMock.mockImplementation((url: string) => {
+ throw new Error(`unexpected messages URL: ${url}`)
+ })
+ let currentFetchOlder = () => {}
+ const renderer = renderCapture(
+ queryClient,
+ React.createElement(DynamicPaginationCapture, {
+ channelId: "ch_a",
+ onRender: (fetchOlder) => { currentFetchOlder = fetchOlder },
+ }),
+ )
+ const oldFetchOlder = currentFetchOlder
+
+ updateCapture(
+ renderer,
+ queryClient,
+ React.createElement(DynamicPaginationCapture, {
+ channelId: null,
+ onRender: (fetchOlder) => { currentFetchOlder = fetchOlder },
+ }),
+ )
+ act(() => oldFetchOlder())
+
+ expect(apiFetchMock).not.toHaveBeenCalled()
+ renderer.unmount()
+ })
+
+ it("keeps cold-restore pagination behind a missing-anchor revalidation", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ const key = communityKeys.channelMessages("ch_activation")
+ queryClient.setQueryData(key, {
+ pages: [{
+ messages: [{ id: "m_newest", seq: 3, createdAt: "2026-08-09T00:00:02.000Z" }],
+ hasMore: true,
+ cursor: "persisted-cursor",
+ latestSeq: 3,
+ }],
+ pageParams: [{ mode: "newest" }],
+ })
+ const anchorResponse = deferred<MessagesPage>()
+ apiFetchMock.mockImplementation((url: string) => {
+ if (url.endsWith("?anchor=m_anchor")) return anchorResponse.promise
+ if (url.endsWith("?cursor=fresh-cursor")) {
+ return Promise.resolve({
+ messages: [{ id: "m_old", seq: 1, createdAt: "2026-08-09T00:00:00.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 3,
+ } satisfies MessagesPage)
+ }
+ throw new Error(`unexpected messages URL: ${url}`)
+ })
+ const snapshots: Snapshot[] = []
+ const renderer = renderCapture(
+ queryClient,
+ React.createElement(LayoutPaginatingChannelCapture, {
+ lastReadMessageId: "m_anchor",
+ onRender: (snapshot) => { snapshots.push(snapshot) },
+ }),
+ )
+
+ await waitFor(() => apiFetchMock.mock.calls.length === 1)
+ expect(apiFetchMock.mock.calls[0]?.[0]).toBe(
+ "/api/community/channels/ch_activation/messages?anchor=m_anchor",
+ )
+
+ anchorResponse.resolve({
+ messages: [{ id: "m_anchor", seq: 2, createdAt: "2026-08-09T00:00:01.000Z" }],
+ hasMoreOlder: true,
+ hasMoreNewer: false,
+ olderCursor: "fresh-cursor",
+ latestSeq: 3,
+ })
+ await waitFor(() => apiFetchMock.mock.calls.length === 2)
+ expect(apiFetchMock.mock.calls[1]?.[0]).toBe(
+ "/api/community/channels/ch_activation/messages?cursor=fresh-cursor",
+ )
+ await waitFor(() => snapshots.at(-1)?.ids.includes("m_old") === true)
+ expect(snapshots.at(-1)?.ids).toEqual(["m_old", "m_anchor"])
+ expect(apiFetchMock.mock.calls.some(
+ ([url]) => url.includes("cursor=persisted-cursor"),
+ )).toBe(false)
+ renderer.unmount()
+ })
+
+ it("drops queued pagination when the conversation changes during revalidation", async () => {
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ queryClient.setQueryData(communityKeys.channelMessages("ch_a"), {
+ pages: [{
+ messages: [{ id: "m_newest_a", seq: 3, createdAt: "2026-08-09T00:00:02.000Z" }],
+ hasMore: true,
+ cursor: "persisted-cursor-a",
+ latestSeq: 3,
+ }],
+ pageParams: [{ mode: "newest" }],
+ })
+ queryClient.setQueryData(communityKeys.channelMessages("ch_b"), {
+ pages: [{
+ messages: [{ id: "m_anchor_ch_b", seq: 4, createdAt: "2026-08-09T00:00:03.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 4,
+ }],
+ pageParams: [{ mode: "anchor", anchor: "m_anchor_ch_b" }],
+ })
+ const anchorResponse = deferred<MessagesPage>()
+ apiFetchMock.mockImplementation((url: string) => {
+ if (url.endsWith("/ch_a/messages?anchor=m_anchor_ch_a")) return anchorResponse.promise
+ if (url.endsWith("/ch_b/messages?anchor=m_anchor_ch_b")) {
+ return Promise.resolve({
+ messages: [{ id: "m_anchor_ch_b", seq: 4, createdAt: "2026-08-09T00:00:03.000Z" }],
+ hasMoreOlder: false,
+ hasMoreNewer: false,
+ latestSeq: 4,
+ } satisfies MessagesPage)
+ }
+ throw new Error(`unexpected messages URL: ${url}`)
+ })
+ const snapshots: Snapshot[] = []
+ const view = (channelId: string, queueOlder: boolean) => React.createElement(
+ SwitchingLayoutPaginationCapture,
+ {
+ channelId,
+ queueOlder,
+ onRender: (snapshot: Snapshot) => { snapshots.push(snapshot) },
+ },
+ )
+ const renderer = renderCapture(queryClient, view("ch_a", true))
+
+ await waitFor(() => apiFetchMock.mock.calls.length === 1)
+ expect(apiFetchMock.mock.calls[0]?.[0]).toBe(
+ "/api/community/channels/ch_a/messages?anchor=m_anchor_ch_a",
+ )
+ updateCapture(renderer, queryClient, view("ch_b", false))
+
+ anchorResponse.resolve({
+ messages: [{ id: "m_anchor_ch_a", seq: 2, createdAt: "2026-08-09T00:00:01.000Z" }],
+ hasMoreOlder: true,
+ hasMoreNewer: false,
+ olderCursor: "fresh-cursor-a",
+ latestSeq: 3,
+ })
+ await act(async () => { await anchorResponse.promise })
+ await act(async () => { await Promise.resolve() })
+ expect(apiFetchMock.mock.calls.map(([url]) => url)).toEqual([
+ "/api/community/channels/ch_a/messages?anchor=m_anchor_ch_a",
+ "/api/community/channels/ch_b/messages?anchor=m_anchor_ch_b",
+ ])
+ expect(snapshots.at(-1)?.ids).toEqual(["m_anchor_ch_b"])
+ renderer.unmount()
+ })
})
diff --git a/src/web/src/hooks/community/use-messages.ts b/src/web/src/hooks/community/use-messages.ts
index a6002c41e..b1ac34675 100644
--- a/src/web/src/hooks/community/use-messages.ts
+++ b/src/web/src/hooks/community/use-messages.ts
@@ -4,12 +4,13 @@ import {
useInfiniteQuery,
focusManager,
onlineManager,
+ useIsRestoring,
useQueryClient,
type UseInfiniteQueryResult,
type InfiniteData,
type QueryClient,
} from "@tanstack/react-query"
-import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react"
import { apiFetchProfiles, messageProfilePatches } from "@/lib/community/profile-seed"
import { captureChannelMetadataToken, isChannelMetadataTokenCurrent } from "@/hooks/community/channel-metadata"
import { communityKeys } from "@/lib/query-keys"
@@ -332,6 +333,12 @@ type PresentOverride = {
viewKey: string
}
+type ActivationRevalidationState = {
+ pending: Promise<unknown> | null
+ requested: boolean
+ viewKey: string
+}
+
// Shared pagination + reducer used by both channel and DM hooks. Kept inline
// as a hook because both variants need the same TanStack setup — factoring
// out a plain function would leak query internals; a hook stays clean.
@@ -345,6 +352,7 @@ function useMessagesInner(
opts: MessagesOpts | undefined,
): MessagesReturn {
const queryClient = useQueryClient()
+ const isRestoring = useIsRestoring()
// `undefined` = anchor snapshot is still resolving; gate the query on it
// being a resolved value (string OR null). Owners without a snapshot
@@ -363,12 +371,18 @@ function useMessagesInner(
() => JSON.stringify([queryKey, opts?.anchorMessageId ?? null]),
[queryKey, opts?.anchorMessageId],
)
+ const activationRevalidationRef = useRef<ActivationRevalidationState>({
+ pending: null,
+ requested: false,
+ viewKey,
+ })
const attemptIdRef = useRef(0)
const snapshotRef = useRef<{
attemptId: number
data: PageCache | undefined
viewKey: string
} | null>(null)
+ const networkFetchObservedRef = useRef(false)
const [presentOverride, setPresentOverride] = useState<PresentOverride | null>(null)
const forceNewest = presentOverride?.viewKey === viewKey
const jumpPending = forceNewest && presentOverride?.phase === "requested"
@@ -387,9 +401,13 @@ function useMessagesInner(
MessagesPageParam
>({
queryKey,
- queryFn: enabled
- ? queryFn
- : () => Promise.reject(new Error("disabled")),
+ // `enabled` is the execution gate. Keep the real transport installed even
+ // while the read-state anchor is resolving: a persisted observer can be
+ // explicitly refetched during the disabled→enabled commit before
+ // TanStack's passive option update runs. Installing a rejecting sentinel
+ // here made that one-shot revalidation fail locally without issuing the
+ // required `/messages` request.
+ queryFn,
initialPageParam,
// "next" = older side. `fetchNextPage` appends to `data.pages`, so the
// LAST entry in `pages` is the oldest window we've loaded — that's the
@@ -411,21 +429,105 @@ function useMessagesInner(
return { mode: "newer", cursor }
},
enabled,
- ...(opts?.revalidateOnMount === false ? { refetchOnMount: false } : {}),
+ // Explicit mount policy is owned below: `false` skips it, `true` performs
+ // the anchor-normalized observer refetch. Disable TanStack's parallel
+ // mount refetch for both so it cannot replay a pre-resolution pageParam.
+ ...(opts?.revalidateOnMount !== undefined ? { refetchOnMount: false } : {}),
refetchOnReconnect: false,
// Message bases are persisted, while accepted/session rows live in an
- // in-memory overlay. Treat each ordinary active message query as stale so
- // disabled→enabled activation revalidates even inside the global 5-second
- // freshness window. TanStack keeps cached pages painted during the fetch.
- // A nonempty window missing the resolved anchor is the one exception: Fix
- // 3 below owns that repair and must fetch the NEW anchor page before any
- // persisted pageParam can replace or discard the existing history.
- staleTime: (cachedQuery) => cachedWindowNeedsAnchorReconcile(
- cachedQuery.state.data as PageCache | undefined,
- forceNewest ? null : anchorId,
- reconcileLateAnchor,
+ // in-memory overlay. Ordinary observers stay stale; opt-in cached mounts
+ // are held fresh only until the anchor-normalized revalidation below owns
+ // their request. Once this mounted observer has seen a real request, hold
+ // it fresh so a later disabled→enabled transition cannot duplicate that
+ // request. TanStack keeps cached pages painted during the fetch. A nonempty
+ // window missing the resolved anchor is also held fresh: Fix 3 below owns
+ // that repair and must fetch the NEW anchor page before any persisted
+ // pageParam can replace or discard the existing history.
+ staleTime: (cachedQuery) => (
+ // Opt-in cached mounts are revalidated explicitly below so the request
+ // can first normalize its semantic page identity. Mark them fresh here
+ // to prevent TanStack's enabled-transition fetch from racing that owner
+ // with a persisted cursor/newest pageParam.
+ (opts?.revalidateOnMount === true && cachedQuery.state.data !== undefined)
+ || networkFetchObservedRef.current
+ || cachedWindowNeedsAnchorReconcile(
+ cachedQuery.state.data as PageCache | undefined,
+ forceNewest ? null : anchorId,
+ reconcileLateAnchor,
+ )
) ? Infinity : 0,
})
+ const refetchMountedObserver = query.refetch
+ const anchorRepairNeeded = cachedWindowNeedsAnchorReconcile(
+ query.data,
+ anchorId,
+ reconcileLateAnchor,
+ )
+ useLayoutEffect(() => {
+ networkFetchObservedRef.current = false
+ const mountedQuery = queryClient.getQueryCache().find({ queryKey, exact: true })
+ if (!mountedQuery) return
+ return queryClient.getQueryCache().subscribe((event) => {
+ if (
+ event.type === "updated"
+ && event.query.queryHash === mountedQuery.queryHash
+ && event.action.type === "success"
+ && !event.action.manual
+ ) {
+ networkFetchObservedRef.current = true
+ }
+ })
+ }, [queryClient, queryKey, viewKey])
+
+ useLayoutEffect(() => {
+ let state = activationRevalidationRef.current
+ if (state.viewKey !== viewKey) {
+ state = { pending: null, requested: false, viewKey }
+ activationRevalidationRef.current = state
+ }
+ if (isRestoring || state.requested) return
+ if (!enabled || query.data === undefined || opts?.revalidateOnMount !== true) return
+
+ // Guarantee one actual post-mount fetch for cached conversation observers.
+ // A retained observer can mount after restore and read-state have already
+ // settled, so neither lifecycle is a reliable prerequisite. Retained cache
+ // writes are also not proof that the network ran. The query-cache
+ // subscription distinguishes manual cache success from a completed
+ // request. Refetch through this observer rather than asking the cache for
+ // "active" queries: while PersistQueryClientProvider hands hydration back
+ // to React, the mounted observer can briefly fail that cache-level filter.
+ // An infinite-query refetch replays its first persisted pageParam. Normalize
+ // that identity to this mount's resolved anchor/newest target first: after
+ // older pagination or hydration the stored first param can be a cursor,
+ // which must never outrun the read-state anchor on a retained mount.
+ // Running in layout also starts the semantic revalidation before the
+ // message-list's passive IntersectionObserver can request another page.
+ state.requested = true
+ if (networkFetchObservedRef.current) return
+ queryClient.setQueryData<PageCache>(queryKey, (current) => current
+ ? {
+ ...current,
+ pageParams: [initialPageParam, ...current.pageParams.slice(1)],
+ }
+ : current)
+ const request = refetchMountedObserver({ cancelRefetch: false })
+ state.pending = request
+ const clearPending = () => {
+ if (state.pending === request) state.pending = null
+ }
+ void request.then(clearPending, clearPending)
+ }, [
+ anchorRepairNeeded,
+ enabled,
+ initialPageParam,
+ isRestoring,
+ opts?.revalidateOnMount,
+ query.data,
+ queryClient,
+ queryKey,
+ refetchMountedObserver,
+ viewKey,
+ ])
useEffect(() => {
setPresentOverride((current) => current?.viewKey === viewKey ? current : null)
@@ -469,7 +571,6 @@ function useMessagesInner(
current?.attemptId === presentOverride.attemptId ? null : current)
}, [jumpPending, presentOverride, query.isError, queryClient, queryKey, viewKey])
- const anchorRepairNeeded = cachedWindowNeedsAnchorReconcile(query.data, anchorId, reconcileLateAnchor)
const messageQuery = queryClient.getQueryCache().find({ queryKey, exact: true })
const settledAnchorRepairRef = useRef<{ key: string; query: unknown } | null>(null)
const anchorRepairFailedRef = useRef(false)
@@ -489,6 +590,10 @@ function useMessagesInner(
if (!enabled) return
if (forceNewest) return
if (!anchorId) return
+ // The opt-in mount owner has already normalized the first page to this
+ // anchor and started its observer refetch. Do not launch the independent
+ // repair path in the same commit before the observer update is rendered.
+ if (activationRevalidationRef.current.pending) return
if (query.isFetching) return
if (query.isPending) return
if (!anchorRepairNeeded || !messageQuery) return
@@ -603,10 +708,33 @@ function useMessagesInner(
// internal state change — closing over the whole query object keeps the
// exhaustive-deps rule happy without spelling every subfield.
const fetchOlder = useCallback(() => {
+ if (!enabled) return
if (!query.hasNextPage) return
if (query.isFetchingNextPage) return
+ const activationState = activationRevalidationRef.current
+ if (activationState.viewKey !== viewKey) return
+ const activationRequest = activationState.pending
+ if (activationRequest) {
+ void activationRequest.then(() => {
+ if (activationRevalidationRef.current.viewKey !== viewKey) return
+ void query.fetchNextPage({ cancelRefetch: false })
+ })
+ return
+ }
+ // Initial-position sentinels can intersect while a retained-mount
+ // revalidation is still in flight. Queue their pagination behind that
+ // semantic request instead of letting fetchNextPage cancel it and make a
+ // cursor GET the first completed request for the mount.
+ if (query.isFetching) {
+ void query.refetch({ cancelRefetch: false }).then(() => {
+ // The observer method reads the just-refreshed page/cursor state. If
+ // that page has no older cursor, TanStack resolves without a request.
+ void query.fetchNextPage({ cancelRefetch: false })
+ })
+ return
+ }
void query.fetchNextPage()
- }, [query])
+ }, [enabled, query, viewKey])
const fetchNewer = useCallback(() => {
if (!query.hasPreviousPage) return
diff --git a/src/web/src/hooks/community/use-scroll-anchor.pagination.dom.test.ts b/src/web/src/hooks/community/use-scroll-anchor.pagination.dom.test.ts
index f99880834..c5ffbb325 100644
--- a/src/web/src/hooks/community/use-scroll-anchor.pagination.dom.test.ts
+++ b/src/web/src/hooks/community/use-scroll-anchor.pagination.dom.test.ts
@@ -45,16 +45,19 @@ const day = (key: string): FlatItem => ({ kind: "date-divider", label: key, key:
function Harness({
items,
isFetchingOlder,
+ isFetchingNewer = false,
onResult,
}: {
items: FlatItem[]
isFetchingOlder: boolean
+ isFetchingNewer?: boolean
onResult: (result: AnchorResult) => void
}) {
const result = useScrollAnchor({
items,
initialScrollReady: false,
isFetchingOlder,
+ isFetchingNewer,
heroHeight: 0,
heroMeasured: false,
})
@@ -72,23 +75,35 @@ function Harness({
describe("useScrollAnchor older-page message anchoring", () => {
let frames: FrameRequestCallback[]
+ let resizeCallbacks: ResizeObserverCallback[]
+ let clientHeight: number
let cancelFrame: ReturnType<typeof vi.fn>
let latest: AnchorResult
beforeEach(() => {
frames = []
+ resizeCallbacks = []
+ clientHeight = 600
harness.absoluteTops.clear()
harness.scroller = null
harness.scrollToIndex.mockClear()
harness.virtualizer.scrollToEnd.mockClear()
+ harness.virtualizer.options.anchorTo = "end"
cancelFrame = vi.fn()
- vi.stubGlobal("ResizeObserver", class { observe() {} disconnect() {} })
+ vi.stubGlobal("ResizeObserver", class {
+ constructor(callback: ResizeObserverCallback) {
+ resizeCallbacks.push(callback)
+ }
+
+ observe() {}
+ disconnect() {}
+ })
vi.spyOn(window, "requestAnimationFrame").mockImplementation((callback) => {
frames.push(callback)
return frames.length
})
vi.spyOn(window, "cancelAnimationFrame").mockImplementation(cancelFrame)
- vi.spyOn(HTMLElement.prototype, "clientHeight", "get").mockReturnValue(600)
+ vi.spyOn(HTMLElement.prototype, "clientHeight", "get").mockImplementation(() => clientHeight)
vi.spyOn(HTMLElement.prototype, "scrollHeight", "get").mockReturnValue(5_000)
vi.spyOn(HTMLElement.prototype, "getBoundingClientRect").mockImplementation(function () {
const element = this as HTMLElement
@@ -138,6 +153,44 @@ describe("useScrollAnchor older-page message anchoring", () => {
return rendered
}
+ function runNewerCase(initialItems: FlatItem[], nextItems: FlatItem[], nextAnchorTop: number) {
+ const onResult = (result: AnchorResult) => { latest = result }
+ harness.absoluteTops.set("anchor", 120)
+ const rendered = render(createElement(Harness, {
+ items: initialItems,
+ isFetchingOlder: false,
+ onResult,
+ }))
+ harness.scroller = screen.getByTestId("scroll") as HTMLDivElement
+
+ act(() => latest.captureNewerPageAnchor())
+ expect(latest.isNewerPageAnchorSettling).toBe(true)
+ expect(harness.virtualizer.options.anchorTo).toBe("start")
+ rendered.rerender(createElement(Harness, {
+ items: initialItems,
+ isFetchingOlder: false,
+ isFetchingNewer: true,
+ onResult,
+ }))
+ harness.scroller.scrollTop = 96
+ harness.scroller.dispatchEvent(new Event("scroll"))
+ harness.absoluteTops.set("anchor", nextAnchorTop)
+ rendered.rerender(createElement(Harness, {
+ items: nextItems,
+ isFetchingOlder: false,
+ isFetchingNewer: false,
+ onResult,
+ }))
+ act(() => {
+ while (frames.length > 0) frames.shift()!(0)
+ })
+
+ const anchor = rendered.container.querySelector<HTMLElement>('[data-msg-id="anchor"]')!
+ expect(anchor.getBoundingClientRect().top).toBe(24)
+ expect(latest.isNewerPageAnchorSettling).toBe(false)
+ return rendered
+ }
+
it("preserves the real message across same-day and cross-day divider shapes", () => {
const initial = [day("2026-09-18"), message("anchor")]
const sameDay = [day("2026-09-18"), message("older"), message("anchor")]
@@ -164,6 +217,77 @@ describe("useScrollAnchor older-page message anchoring", () => {
rendered.unmount()
})
+ it("keeps a settled older-page anchor through the following viewport resize", () => {
+ const initial = [day("2026-09-18"), message("anchor")]
+ const prepended = [day("2026-09-18"), message("older"), message("anchor")]
+ const rendered = runCase(initial, prepended, 520)
+ const anchor = rendered.container.querySelector<HTMLElement>('[data-msg-id="anchor"]')!
+
+ expect(harness.scroller!.scrollTop).toBe(400)
+ clientHeight = 500
+ act(() => resizeCallbacks.at(-1)?.([], {} as ResizeObserver))
+
+ expect(harness.scroller!.scrollTop).toBe(400)
+ expect(anchor.getBoundingClientRect().top).toBe(120)
+ rendered.unmount()
+ })
+
+ it("preserves the real message while a newer page appends at the loaded-window tail", () => {
+ const initial = [day("2026-09-18"), message("anchor")]
+ const appended = [
+ day("2026-09-18"),
+ message("anchor"),
+ message("newer"),
+ ]
+ const rendered = runNewerCase(initial, appended, 120)
+ expect(harness.scrollToIndex).toHaveBeenLastCalledWith(1, { align: "start" })
+ expect(harness.virtualizer.scrollToEnd).not.toHaveBeenCalled()
+ rendered.unmount()
+ })
+
+ it("captures newer-page scrollTop even when virtual rows lag the end intersection", () => {
+ const onResult = (result: AnchorResult) => { latest = result }
+ harness.absoluteTops.set("anchor", 2_000)
+ const initial = [message("anchor")]
+ const rendered = render(createElement(Harness, {
+ items: initial,
+ isFetchingOlder: false,
+ onResult,
+ }))
+ harness.scroller = screen.getByTestId("scroll") as HTMLDivElement
+ harness.scroller.scrollTop = 300
+
+ act(() => latest.captureNewerPageAnchor())
+ expect(latest.isNewerPageAnchorSettling).toBe(true)
+ rendered.rerender(createElement(Harness, {
+ items: initial,
+ isFetchingOlder: false,
+ isFetchingNewer: true,
+ onResult,
+ }))
+ harness.scroller.scrollTop = 1_000
+ harness.scroller.dispatchEvent(new Event("scroll"))
+ harness.scroller.scrollTop = 1_400
+ rendered.rerender(createElement(Harness, {
+ items: [...initial, message("newer")],
+ isFetchingOlder: false,
+ isFetchingNewer: false,
+ onResult,
+ }))
+ expect(harness.scroller.scrollTop).toBe(1_000)
+ // A virtualizer/browser write can land between the synchronous restore
+ // and its first reconciliation frame. The numeric fallback must repair
+ // that drift even though no real row was visible at capture time.
+ harness.scroller.scrollTop = 1_400
+ act(() => {
+ while (frames.length > 0) frames.shift()!(0)
+ })
+
+ expect(harness.scroller.scrollTop).toBe(1_000)
+ expect(latest.isNewerPageAnchorSettling).toBe(false)
+ rendered.unmount()
+ })
+
it("cancels a pending reconciliation before capturing a replacement anchor", () => {
const onResult = (result: AnchorResult) => { latest = result }
const initial = [message("anchor")]
diff --git a/src/web/src/hooks/community/use-scroll-anchor.repin.test.ts b/src/web/src/hooks/community/use-scroll-anchor.repin.test.ts
index bfc55985f..a83f1d3d2 100644
--- a/src/web/src/hooks/community/use-scroll-anchor.repin.test.ts
+++ b/src/web/src/hooks/community/use-scroll-anchor.repin.test.ts
@@ -12,8 +12,8 @@ let refs: Array<{ current: unknown }> = []
let refIndex = 0
let layoutEffects: Array<() => void | (() => void)> = []
let resizeCallbacks: ResizeObserverCallback[] = []
-const OLDER_PAGE_ANCHOR_FRAME_REF_INDEX = 13
-const OLDER_PAGE_UNMOUNT_EFFECT_INDEX = 2
+const PAGINATION_ANCHOR_FRAME_REF_INDEX = 14
+const PAGINATION_UNMOUNT_EFFECT_INDEX = 2
vi.mock("react", () => ({
useRef: (initial: unknown) => {
@@ -234,9 +234,9 @@ afterEach(() => vi.unstubAllGlobals())
describe("useScrollAnchor delayed row-growth re-pin", () => {
it("cancels a pending older-page frame from the unmount fallback", async () => {
await mountHook()
- const olderPageAnchorFrameRef = refs[OLDER_PAGE_ANCHOR_FRAME_REF_INDEX]
- olderPageAnchorFrameRef.current = 42
- const cleanup = layoutEffects[OLDER_PAGE_UNMOUNT_EFFECT_INDEX]()
+ const paginationAnchorFrameRef = refs[PAGINATION_ANCHOR_FRAME_REF_INDEX]
+ paginationAnchorFrameRef.current = 42
+ const cleanup = layoutEffects[PAGINATION_UNMOUNT_EFFECT_INDEX]()
expect(cleanup).toBeTypeOf("function")
cleanup!()
@@ -351,118 +351,110 @@ describe("useScrollAnchor delayed row-growth re-pin", () => {
})
})
-const EXACT_PIN_BOUNDARIES = [0, 1, 2, 99, 100, 101, 300]
+const VIEWPORT_RESIZE_BOUNDARIES = [0, 1, 2, 99, 100, 101, 300]
-describe("useScrollAnchor viewport resize exact-pinned latch", () => {
- it.each(EXACT_PIN_BOUNDARIES)(
- "uses the resize end writer only for an initial %ipx distance when the viewport grows",
+describe("useScrollAnchor semantic viewport resize anchoring", () => {
+ it("ignores a ResizeObserver delivery when the viewport height is unchanged", async () => {
+ const mounted = await mountHook({ distanceToEnd: 2 })
+ const before = mounted.geometry()
+
+ mounted.resizeViewport(before.clientHeight)
+
+ expect(mounted.geometry()).toEqual(before)
+ expect(mounted.scrollWrites).toEqual([])
+ })
+
+ it.each(VIEWPORT_RESIZE_BOUNDARIES)(
+ "resolves a composer growth from an initial %ipx tail distance",
async (distanceToEnd) => {
- const { resizeViewport } = await mountHook({ distanceToEnd })
+ const { geometry, resizeViewport } = await mountHook({ distanceToEnd })
resizeViewport(799)
- expect(virtualizer.scrollToEnd).toHaveBeenCalledTimes(distanceToEnd <= 1 ? 1 : 0)
+ const expectedScrollTop = distanceToEnd <= 100
+ ? 1_600 - 799 - distanceToEnd
+ : 1_600 - 800 - distanceToEnd
+ expect(geometry()).toEqual({
+ clientHeight: 799,
+ scrollHeight: 1_600,
+ scrollTop: expectedScrollTop,
+ })
+ expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
},
)
- it.each(EXACT_PIN_BOUNDARIES)(
- "uses the resize end writer only for an initial %ipx distance when the viewport shrinks",
+ it.each(VIEWPORT_RESIZE_BOUNDARIES)(
+ "resolves a composer shrink from an initial %ipx tail distance",
async (distanceToEnd) => {
- const { resizeViewport } = await mountHook({ distanceToEnd })
+ const { geometry, resizeViewport } = await mountHook({ distanceToEnd })
resizeViewport(801)
- expect(virtualizer.scrollToEnd).toHaveBeenCalledTimes(distanceToEnd <= 1 ? 1 : 0)
+ const expectedScrollTop = distanceToEnd <= 100
+ ? 1_600 - 801 - distanceToEnd
+ : 1_600 - 800 - distanceToEnd
+ expect(geometry()).toEqual({
+ clientHeight: 801,
+ scrollHeight: 1_600,
+ scrollTop: expectedScrollTop,
+ })
+ expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
},
)
- it("promotes false only after a stable scroll moves toward the literal end", async () => {
- const { dispatchScroll, geometry, resizeViewport, setBrowserScrollTop } = await mountHook({
- distanceToEnd: 2,
- })
-
- setBrowserScrollTop(geometry().scrollHeight - geometry().clientHeight)
- dispatchScroll()
- resizeViewport(799)
-
- expect(virtualizer.scrollToEnd).toHaveBeenCalledTimes(1)
- })
-
- it("does not promote false when content shrink reaches 1px at the same scrollTop", async () => {
- const { dispatchScroll, geometry, resizeViewport, setScrollHeight } = await mountHook({
- distanceToEnd: 2,
- })
-
- setScrollHeight(geometry().scrollHeight - 1)
- dispatchScroll()
- resizeViewport(799)
-
- expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
- })
+ it("preserves tail distance regardless of scroll/resize callback ordering", async () => {
+ for (const order of ["scroll-ro", "ro-scroll"] as const) {
+ const mounted = await mountHook({ distanceToEnd: 2 })
- it("clears exact-pinned immediately on existing upward wheel and keyboard intent", async () => {
- const wheel = await mountHook({ distanceToEnd: 0 })
- wheel.listeners.get("wheel")?.({ deltaY: -1 } as WheelEvent)
- wheel.resizeViewport(799)
- expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
+ mounted.resizeViewport(803, order)
- resetHarness()
- const keyboard = await mountHook({ distanceToEnd: 0 })
- keyboard.listeners.get("keydown")?.({ key: "PageUp" } as KeyboardEvent)
- keyboard.resizeViewport(799)
- expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
+ const { clientHeight, scrollHeight, scrollTop } = mounted.geometry()
+ expect(scrollHeight - clientHeight - scrollTop).toBe(2)
+ resetHarness()
+ }
})
- it.each(["scroll-ro", "ro-scroll"] as const)(
- "keeps a clamped false latch false through a second resize for %s ordering",
- async (order) => {
- const { resizeViewport } = await mountHook({ distanceToEnd: 2 })
-
- // Growing the viewport by 3px clamps the browser scrollTop down to its
- // new max. Whether that scroll callback runs before or after RO, it must
- // not turn the original 2px-away latch true.
- resizeViewport(803, order)
- resizeViewport(799, "ro-scroll")
-
- expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
- },
- )
-
it.each([
{ name: "grow→grow", heights: [780, 760] },
{ name: "shrink→shrink", heights: [801, 802] },
{ name: "grow→shrink", heights: [780, 800] },
- ])("preserves a false latch across rapid $name viewport sequences", async ({ heights }) => {
- const { resizeViewport } = await mountHook({ distanceToEnd: 2 })
+ ])("preserves a 2px tail distance across rapid $name sequences", async ({ heights }) => {
+ const { geometry, resizeViewport } = await mountHook({ distanceToEnd: 2 })
for (const height of heights) resizeViewport(height)
- expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
+ const { clientHeight, scrollHeight, scrollTop } = geometry()
+ expect(scrollHeight - clientHeight - scrollTop).toBe(2)
})
- it("keeps an exact-pinned latch continuous across rapid grow and shrink", async () => {
- const { resizeViewport } = await mountHook({ distanceToEnd: 1 })
+ it("preserves a 300px reading scrollTop across rapid growth and shrink", async () => {
+ const { geometry, resizeViewport } = await mountHook({ distanceToEnd: 300 })
+ const initialScrollTop = geometry().scrollTop
resizeViewport(780)
resizeViewport(760)
resizeViewport(800)
- expect(virtualizer.scrollToEnd).toHaveBeenCalledTimes(3)
+ expect(geometry().scrollTop).toBe(initialScrollTop)
})
it("lets the existing explicit end action restore the latch", async () => {
- const { resizeViewport, result } = await mountHook({ distanceToEnd: 300 })
+ const { dispatchScroll, geometry, resizeViewport, result } = await mountHook({
+ distanceToEnd: 300,
+ })
result.scrollToBottom()
+ dispatchScroll()
virtualizer.scrollToEnd.mockClear()
resizeViewport(799)
- expect(virtualizer.scrollToEnd).toHaveBeenCalledTimes(1)
+ expect(geometry().scrollHeight - geometry().clientHeight - geometry().scrollTop).toBe(0)
+ expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
})
it("restores the latch for warm-mount and peer-follow end actions", async () => {
const first = messageItem("m1", "peer")
- const { rerender, resizeViewport } = await mountHook({
+ const { geometry, rerender, resizeViewport } = await mountHook({
distanceToEnd: 2,
items: [first],
heroMeasured: true,
@@ -481,11 +473,12 @@ describe("useScrollAnchor viewport resize exact-pinned latch", () => {
virtualizer.scrollToEnd.mockClear()
resizeViewport(799)
- expect(virtualizer.scrollToEnd).toHaveBeenCalledTimes(1)
+ expect(geometry().scrollHeight - geometry().clientHeight - geometry().scrollTop).toBe(0)
+ expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
})
it("restores the latch for an explicit present action", async () => {
- const { resizeViewport } = await mountHook({
+ const { geometry, resizeViewport } = await mountHook({
distanceToEnd: 300,
items: [messageItem("m1")],
presentVersion: 1,
@@ -496,7 +489,8 @@ describe("useScrollAnchor viewport resize exact-pinned latch", () => {
virtualizer.scrollToEnd.mockClear()
resizeViewport(799)
- expect(virtualizer.scrollToEnd).toHaveBeenCalledTimes(1)
+ expect(geometry().scrollHeight - geometry().clientHeight - geometry().scrollTop).toBe(0)
+ expect(virtualizer.scrollToEnd).not.toHaveBeenCalled()
})
it("re-pins an exactly pinned image load but ignores one after upward intent", async () => {
diff --git a/src/web/src/hooks/community/use-scroll-anchor.test.ts b/src/web/src/hooks/community/use-scroll-anchor.test.ts
index 617a9424b..3ed927bba 100644
--- a/src/web/src/hooks/community/use-scroll-anchor.test.ts
+++ b/src/web/src/hooks/community/use-scroll-anchor.test.ts
@@ -8,6 +8,7 @@ import {
extractScrollAnchorMessages,
measureMessageRow,
NEAR_BOTTOM_PX,
+ resolveViewportResizeAnchor,
shouldAdjustMessageScrollPosition,
type ScrollAnchorState,
type ScrollAnchorMessage,
@@ -17,6 +18,50 @@ import type { VirtualItem } from "@tanstack/react-virtual"
const msgs = (...ids: string[]): ScrollAnchorMessage[] => ids.map((id) => ({ id }))
+describe("resolveViewportResizeAnchor", () => {
+ it.each([0, 2, 100])("preserves a %ipx tail distance across footer growth", (distance) => {
+ expect(resolveViewportResizeAnchor({
+ previousClientHeight: 800,
+ nextClientHeight: 608,
+ previousScrollHeight: 1_600,
+ nextScrollHeight: 1_600,
+ previousScrollTop: 800 - distance,
+ })).toEqual({
+ anchor: "tail",
+ scrollTop: 992 - distance,
+ distanceToEnd: distance,
+ })
+ })
+
+ it("preserves a 300px reading position across footer growth", () => {
+ expect(resolveViewportResizeAnchor({
+ previousClientHeight: 800,
+ nextClientHeight: 608,
+ previousScrollHeight: 1_600,
+ nextScrollHeight: 1_600,
+ previousScrollTop: 500,
+ })).toEqual({
+ anchor: "start",
+ scrollTop: 500,
+ distanceToEnd: 300,
+ })
+ })
+
+ it("uses tail distance when viewport expansion makes the old top impossible", () => {
+ expect(resolveViewportResizeAnchor({
+ previousClientHeight: 608,
+ nextClientHeight: 800,
+ previousScrollHeight: 1_600,
+ nextScrollHeight: 1_600,
+ previousScrollTop: 842,
+ })).toEqual({
+ anchor: "tail",
+ scrollTop: 650,
+ distanceToEnd: 150,
+ })
+ })
+})
+
function baseInput(overrides: Partial<Parameters<typeof decideScrollAction>[0]> = {}) {
return {
state: createScrollAnchorState(),
@@ -232,6 +277,19 @@ describe("decideScrollAction — self-send / peer-follow (both hand-rolled — f
expect(action).toEqual({ type: "none" })
})
+ it("newer-page pagination never follows the changed tail as a live append", () => {
+ const state = mountedState()
+ const messages = [{ id: "m1" }, { id: "m2" }, { id: "m3" }, { id: "m4", authorId: "peer" }]
+ const { action } = decideScrollAction(baseInput({
+ state,
+ messages,
+ hasMoreNewer: false,
+ isPaginatingNewer: true,
+ isAtEnd: true,
+ }))
+ expect(action).toEqual({ type: "none" })
+ })
+
it("no action when the tail id is unchanged", () => {
const state = mountedState()
const { action } = decideScrollAction(baseInput({ state, viewerUserId: "viewer" }))
diff --git a/src/web/src/hooks/community/use-scroll-anchor.ts b/src/web/src/hooks/community/use-scroll-anchor.ts
index c44204c3f..57c0341d9 100644
--- a/src/web/src/hooks/community/use-scroll-anchor.ts
+++ b/src/web/src/hooks/community/use-scroll-anchor.ts
@@ -41,6 +41,62 @@ import { estimateRowHeight, computeBelowCount, type FlatItem } from "@/lib/commu
// `resizeItem` above-viewport compensation (defaults to 1px otherwise).
export const NEAR_BOTTOM_PX = 100
+type ViewportResizeAnchor = "tail" | "start"
+
+export interface ResolveViewportResizeAnchorInput {
+ previousClientHeight: number
+ nextClientHeight: number
+ previousScrollHeight: number
+ nextScrollHeight: number
+ previousScrollTop: number
+}
+
+export interface ViewportResizeAnchorResult {
+ anchor: ViewportResizeAnchor
+ scrollTop: number
+ distanceToEnd: number
+}
+
+/**
+ * Resolve a conversation viewport resize from the last accepted geometry.
+ *
+ * Composer growth/shrink is a real normal-flow resize. Viewers in tail
+ * context retain their exact distance from the end, while readers farther
+ * away retain their top-based position. When the viewport grows by more than
+ * the old tail distance, a top anchor is physically impossible because the
+ * browser must clamp to the new maximum; that case deliberately falls back
+ * to the equivalent tail-distance anchor.
+ */
+export function resolveViewportResizeAnchor({
+ previousClientHeight,
+ nextClientHeight,
+ previousScrollHeight,
+ nextScrollHeight,
+ previousScrollTop,
+}: ResolveViewportResizeAnchorInput): ViewportResizeAnchorResult {
+ const distanceToEnd = Math.max(
+ 0,
+ previousScrollHeight - previousClientHeight - previousScrollTop,
+ )
+ const viewportGrowth = Math.max(0, nextClientHeight - previousClientHeight)
+ const anchor: ViewportResizeAnchor = distanceToEnd <= Math.max(
+ NEAR_BOTTOM_PX,
+ viewportGrowth,
+ )
+ ? "tail"
+ : "start"
+ const maxScrollTop = Math.max(0, nextScrollHeight - nextClientHeight)
+ const requestedScrollTop = anchor === "tail"
+ ? maxScrollTop - distanceToEnd
+ : previousScrollTop
+
+ return {
+ anchor,
+ scrollTop: Math.max(0, Math.min(requestedScrollTop, maxScrollTop)),
+ distanceToEnd,
+ }
+}
+
/**
* Measure the row's current visual footprint instead of trusting the initial
* text estimate or a previously cached measurement. The virtualizer's default
@@ -104,8 +160,10 @@ export interface ScrollAnchorMessage {
}
interface PaginationAnchor {
- messageId: string
- viewportOffset: number
+ direction: "older" | "newer"
+ messageId: string | null
+ viewportOffset: number | null
+ scrollTop: number
}
export interface ScrollAnchorState {
@@ -147,6 +205,7 @@ export interface DecideScrollActionInput {
// useChannelWatermark never advances the read pointer.
heroMeasured: boolean
hasMoreNewer?: boolean
+ isPaginatingNewer?: boolean
viewerUserId?: string
// Whether the viewport was within NEAR_BOTTOM_PX of the end BEFORE this
// commit's append — the caller reads this off `virtualizer.isAtEnd(NEAR_BOTTOM_PX)`.
@@ -179,7 +238,7 @@ export interface DecideScrollActionResult {
* real virtualizer. Exported for unit testing without DOM/hooks.
*/
export function decideScrollAction(input: DecideScrollActionInput): DecideScrollActionResult {
- const { state, messages, newDividerBefore, initialScrollReady, heroMeasured, hasMoreNewer, viewerUserId, isAtEnd, userScrolledAway } = input
+ const { state, messages, newDividerBefore, initialScrollReady, heroMeasured, hasMoreNewer, isPaginatingNewer, viewerUserId, isAtEnd, userScrolledAway } = input
const nextTail = messages[messages.length - 1]?.id ?? null
const nextLen = messages.length
@@ -292,6 +351,14 @@ export function decideScrollAction(input: DecideScrollActionInput): DecideScroll
// one-shot is spent (any pending convergence would now be a stale yank), so
// consume it on every tail-changed outcome below.
const liveState = { ...baseNextState, didDividerConverge: true }
+ // A newer-page fetch also changes the tail id, but it is historical
+ // pagination rather than a live append. Its captured visible-message
+ // anchor owns the viewport; treating it as peer-follow would snap to the
+ // newly loaded page end and can virtualize the captured row away before
+ // reconciliation gets a chance to restore it.
+ if (isPaginatingNewer) {
+ return { action: { type: "none" }, nextState: liveState }
+ }
const tail = messages[messages.length - 1]
const isSelfSend = !!viewerUserId && tail?.authorId === viewerUserId
if (isSelfSend) {
@@ -396,6 +463,7 @@ export function useScrollAnchor({
initialScrollReady,
hasMoreNewer,
isFetchingOlder,
+ isFetchingNewer,
presentVersion,
viewerUserId,
heroHeight,
@@ -407,6 +475,7 @@ export function useScrollAnchor({
initialScrollReady: boolean
hasMoreNewer?: boolean
isFetchingOlder?: boolean
+ isFetchingNewer?: boolean
presentVersion?: number
viewerUserId?: string
// Current measured height (px) of the non-virtualized hero block that
@@ -431,6 +500,8 @@ export function useScrollAnchor({
onImageLoad: () => void
captureOlderPageAnchor: () => void
isOlderPageAnchorSettling: boolean
+ captureNewerPageAnchor: () => void
+ isNewerPageAnchorSettling: boolean
} {
const scrollRef = useRef<HTMLDivElement>(null)
const stateRef = useRef<ScrollAnchorState>(createScrollAnchorState())
@@ -445,11 +516,17 @@ export function useScrollAnchor({
const acceptedScrollTopRef = useRef(0)
const measuredRowHeightsRef = useRef(new WeakMap<Element, number>())
const bottomRepinQueuedRef = useRef(false)
- const olderPageAnchorRef = useRef<PaginationAnchor | null>(null)
- const olderPageFetchObservedRef = useRef(false)
- const olderPageAnchorFrameRef = useRef<number | null>(null)
- const [isOlderPageAnchorSettling, setIsOlderPageAnchorSettling] = useState(false)
- const liveResizeAnchor = wasExactlyPinnedRef.current && !userScrolledAwayRef.current
+ const paginationAnchorRef = useRef<PaginationAnchor | null>(null)
+ const paginationFetchObservedRef = useRef(false)
+ const newerPageFetchActiveRef = useRef(false)
+ const paginationAnchorFrameRef = useRef<number | null>(null)
+ const acceptedScrollHeightRef = useRef(0)
+ const [paginationDirection, setPaginationDirection] = useState<"older" | "newer" | null>(null)
+ const isOlderPageAnchorSettling = paginationDirection === "older"
+ const isNewerPageAnchorSettling = paginationDirection === "newer"
+ const liveResizeAnchor = !isNewerPageAnchorSettling
+ && wasExactlyPinnedRef.current
+ && !userScrolledAwayRef.current
? "end"
: "start"
const cancelInitialSettleFrame = useCallback(() => {
@@ -561,7 +638,7 @@ export function useScrollAnchor({
// prepend anchoring before this assignment restores the live resize mode.
virtualizer.options.anchorTo = liveResizeAnchor
- const captureOlderPageAnchor = useCallback(() => {
+ const capturePageAnchor = useCallback((direction: "older" | "newer") => {
const root = scrollRef.current
if (!root) return
const rootRect = root.getBoundingClientRect()
@@ -571,45 +648,76 @@ export function useScrollAnchor({
return rect.bottom > rootRect.top + 1 && rect.top < rootRect.bottom - 1
})
const messageId = row?.dataset.msgId
- if (!row || !messageId) return
- if (olderPageAnchorFrameRef.current !== null) {
- window.cancelAnimationFrame(olderPageAnchorFrameRef.current)
- olderPageAnchorFrameRef.current = null
+ // Older-page prepends require a real-message anchor because content is
+ // inserted above the viewport. Newer pages append below it, so the exact
+ // scrollTop is itself a stable anchor and also covers the brief moment
+ // where the virtualizer has not mounted the newly visible end rows yet.
+ if (direction === "older" && (!row || !messageId)) return
+ if (paginationAnchorFrameRef.current !== null) {
+ window.cancelAnimationFrame(paginationAnchorFrameRef.current)
+ paginationAnchorFrameRef.current = null
}
- olderPageAnchorRef.current = {
- messageId,
- viewportOffset: row.getBoundingClientRect().top - rootRect.top,
+ paginationAnchorRef.current = {
+ direction,
+ messageId: messageId ?? null,
+ viewportOffset: row ? row.getBoundingClientRect().top - rootRect.top : null,
+ scrollTop: root.scrollTop,
}
- olderPageFetchObservedRef.current = false
- setIsOlderPageAnchorSettling(true)
+ paginationFetchObservedRef.current = false
+ newerPageFetchActiveRef.current = direction === "newer"
+ setPaginationDirection(direction)
}, [])
+ const captureOlderPageAnchor = useCallback(
+ () => capturePageAnchor("older"),
+ [capturePageAnchor],
+ )
+ const captureNewerPageAnchor = useCallback(
+ () => capturePageAnchor("newer"),
+ [capturePageAnchor],
+ )
useLayoutEffect(() => {
- const anchor = olderPageAnchorRef.current
+ const anchor = paginationAnchorRef.current
if (!anchor) return
- if (isFetchingOlder) {
- olderPageFetchObservedRef.current = true
+ const isFetching = anchor.direction === "older" ? isFetchingOlder : isFetchingNewer
+ if (isFetching) {
+ paginationFetchObservedRef.current = true
return
}
- if (!olderPageFetchObservedRef.current) return
+ if (!paginationFetchObservedRef.current) return
+ newerPageFetchActiveRef.current = false
const root = scrollRef.current
- const index = findMessageIndex(items, anchor.messageId)
- if (!root || index === null) {
- olderPageAnchorRef.current = null
- setIsOlderPageAnchorSettling(false)
+ const index = anchor.messageId === null ? null : findMessageIndex(items, anchor.messageId)
+ if (!root || (anchor.direction === "older" && index === null)) {
+ paginationAnchorRef.current = null
+ setPaginationDirection(null)
return
}
+ const acceptGeometry = () => {
+ acceptedClientHeightRef.current = root.clientHeight
+ acceptedScrollTopRef.current = root.scrollTop
+ acceptedScrollHeightRef.current = root.scrollHeight
+ }
- virtualizer.scrollToIndex(index, { align: "start" })
+ // Newer pages only add rows below the viewport. Restore the captured
+ // numeric position synchronously before any tail-follow or measurement
+ // callback can leave the captured row outside the mounted range. When a
+ // real row was available at capture time, the rAF loop below additionally
+ // reconciles its precise visual offset after it remounts.
+ if (anchor.direction === "newer") root.scrollTop = anchor.scrollTop
+ if (index !== null) virtualizer.scrollToIndex(index, { align: "start" })
+ acceptGeometry()
let attempts = 0
let stableFrames = 0
const restore = () => {
- olderPageAnchorFrameRef.current = null
- if (olderPageAnchorRef.current !== anchor) return
- const row = Array.from(root.querySelectorAll<HTMLElement>("[data-msg-id]"))
- .find((candidate) => candidate.dataset.msgId === anchor.messageId)
- if (row) {
+ paginationAnchorFrameRef.current = null
+ if (paginationAnchorRef.current !== anchor) return
+ const row = anchor.messageId === null
+ ? undefined
+ : Array.from(root.querySelectorAll<HTMLElement>("[data-msg-id]"))
+ .find((candidate) => candidate.dataset.msgId === anchor.messageId)
+ if (row && anchor.viewportOffset !== null) {
const offset = row.getBoundingClientRect().top - root.getBoundingClientRect().top
const delta = offset - anchor.viewportOffset
if (Math.abs(delta) > 0.5) {
@@ -618,27 +726,36 @@ export function useScrollAnchor({
} else {
stableFrames += 1
}
+ } else if (anchor.direction === "newer") {
+ const delta = root.scrollTop - anchor.scrollTop
+ if (Math.abs(delta) > 0.5) {
+ root.scrollTop = anchor.scrollTop
+ stableFrames = 0
+ } else {
+ stableFrames += 1
+ }
}
+ acceptGeometry()
attempts += 1
if (stableFrames >= 2 || attempts >= 12) {
- olderPageAnchorRef.current = null
- setIsOlderPageAnchorSettling(false)
+ paginationAnchorRef.current = null
+ setPaginationDirection(null)
return
}
- olderPageAnchorFrameRef.current = window.requestAnimationFrame(restore)
+ paginationAnchorFrameRef.current = window.requestAnimationFrame(restore)
}
- olderPageAnchorFrameRef.current = window.requestAnimationFrame(restore)
+ paginationAnchorFrameRef.current = window.requestAnimationFrame(restore)
return () => {
- if (olderPageAnchorFrameRef.current !== null) {
- window.cancelAnimationFrame(olderPageAnchorFrameRef.current)
- olderPageAnchorFrameRef.current = null
+ if (paginationAnchorFrameRef.current !== null) {
+ window.cancelAnimationFrame(paginationAnchorFrameRef.current)
+ paginationAnchorFrameRef.current = null
}
}
- }, [isFetchingOlder, items, virtualizer])
+ }, [isFetchingNewer, isFetchingOlder, items, virtualizer])
useLayoutEffect(() => () => {
- if (olderPageAnchorFrameRef.current !== null) {
- window.cancelAnimationFrame(olderPageAnchorFrameRef.current)
+ if (paginationAnchorFrameRef.current !== null) {
+ window.cancelAnimationFrame(paginationAnchorFrameRef.current)
}
}, [])
@@ -658,12 +775,27 @@ export function useScrollAnchor({
if (!el) return
acceptedClientHeightRef.current = el.clientHeight
acceptedScrollTopRef.current = el.scrollTop
+ acceptedScrollHeightRef.current = el.scrollHeight
wasExactlyPinnedRef.current = Math.max(
0,
el.scrollHeight - el.clientHeight - el.scrollTop,
) <= 1
const onScroll = () => {
const nextScrollTop = el.scrollTop
+ const paginationAnchor = paginationAnchorRef.current
+ if (newerPageFetchActiveRef.current && paginationAnchor?.direction === "newer") {
+ const rootRect = el.getBoundingClientRect()
+ const row = Array.from(el.querySelectorAll<HTMLElement>("[data-msg-id]"))
+ .find((candidate) => {
+ const rect = candidate.getBoundingClientRect()
+ return rect.bottom > rootRect.top + 1 && rect.top < rootRect.bottom - 1
+ })
+ paginationAnchor.scrollTop = nextScrollTop
+ paginationAnchor.messageId = row?.dataset.msgId ?? null
+ paginationAnchor.viewportOffset = row
+ ? row.getBoundingClientRect().top - rootRect.top
+ : null
+ }
const isAtEnd = virtualizer.isAtEnd(NEAR_BOTTOM_PX)
const leftEnd = wasAtEndRef.current && !isAtEnd
wasAtEndRef.current = isAtEnd
@@ -689,6 +821,7 @@ export function useScrollAnchor({
wasExactlyPinnedRef.current = true
}
acceptedScrollTopRef.current = nextScrollTop
+ acceptedScrollHeightRef.current = el.scrollHeight
}
virtualizer.options.anchorTo = wasExactlyPinnedRef.current && !userScrolledAwayRef.current
? "end"
@@ -726,6 +859,7 @@ export function useScrollAnchor({
initialScrollReady,
heroMeasured,
hasMoreNewer,
+ isPaginatingNewer: isNewerPageAnchorSettling,
viewerUserId,
isAtEnd: wasAtEndRef.current,
userScrolledAway: userScrolledAwayRef.current,
@@ -765,6 +899,7 @@ export function useScrollAnchor({
initialScrollReady,
heroMeasured,
hasMoreNewer,
+ isNewerPageAnchorSettling,
viewerUserId,
virtualizer,
cancelInitialSettleFrame,
@@ -806,18 +941,14 @@ export function useScrollAnchor({
if (delta !== 0) el.scrollTop += delta
}, [heroHeight])
- // Viewport resize compensation — shell or mobile-keyboard changes can alter
- // this viewport's `clientHeight`, and the bottom-pinned content
- // (`min-h-full … justify-end`) would otherwise appear to jump. The channel
- // composer's internal growth is isolated by its stable overlay shell and
- // does not reach this observer. A `ResizeObserver` on the viewport itself
- // catches every real viewport resize. Only a viewport literally pinned within
- // 1px re-pins instantly (NOT the smooth `scrollToBottom` — a smooth
- // animation firing on every keystroke resize is janky and fights rapid
- // successive resizes). Every away position is left to the browser; in
- // particular, the resize policy never writes a compensating height delta.
- // Keyed on `clientHeight`, orthogonal to the hero compensation above (keyed
- // on `heroHeight`) — separate effects, no double-apply.
+ // Viewport resize compensation — composer growth/shrink and mobile-keyboard
+ // changes both alter this viewport's real `clientHeight`. Preserve the
+ // conversation's semantic anchor from the last accepted geometry: exact
+ // distance-to-tail through the shared 100px tail context, otherwise the
+ // reading scrollTop. This is the sole writer for footer-driven viewport
+ // changes; the footer itself does not measure or mutate the message list.
+ // Keyed on `clientHeight`, orthogonal to hero compensation above (keyed on
+ // `heroHeight`) — separate effects, no double-apply.
useLayoutEffect(() => {
const el = scrollRef.current
if (!el) return
@@ -826,18 +957,29 @@ export function useScrollAnchor({
// callback computes a zero delta instead of a spurious jump at mount.
acceptedClientHeightRef.current = el.clientHeight
acceptedScrollTopRef.current = el.scrollTop
+ acceptedScrollHeightRef.current = el.scrollHeight
const ro = new ResizeObserver(() => {
- const prev = acceptedClientHeightRef.current
- const next = el.clientHeight
- if (next === prev) return
- const wasExactlyPinned = wasExactlyPinnedRef.current
- acceptedClientHeightRef.current = next
- acceptedScrollTopRef.current = el.scrollTop
- if (wasExactlyPinned && !userScrolledAwayRef.current) {
- wasExactlyPinnedRef.current = true
- virtualizer.options.anchorTo = "end"
- virtualizer.scrollToEnd()
+ const previousClientHeight = acceptedClientHeightRef.current
+ const nextClientHeight = el.clientHeight
+ if (nextClientHeight === previousClientHeight) return
+ const result = resolveViewportResizeAnchor({
+ previousClientHeight,
+ nextClientHeight,
+ previousScrollHeight: acceptedScrollHeightRef.current,
+ nextScrollHeight: el.scrollHeight,
+ previousScrollTop: acceptedScrollTopRef.current,
+ })
+ if (Math.abs(el.scrollTop - result.scrollTop) > 0.5) {
+ el.scrollTop = result.scrollTop
}
+ acceptedClientHeightRef.current = nextClientHeight
+ acceptedScrollTopRef.current = el.scrollTop
+ acceptedScrollHeightRef.current = el.scrollHeight
+ wasAtEndRef.current = result.distanceToEnd <= NEAR_BOTTOM_PX
+ wasExactlyPinnedRef.current = result.distanceToEnd <= 1
+ virtualizer.options.anchorTo = wasExactlyPinnedRef.current && !userScrolledAwayRef.current
+ ? "end"
+ : "start"
})
ro.observe(el)
return () => ro.disconnect()
@@ -897,5 +1039,7 @@ export function useScrollAnchor({
onImageLoad,
captureOlderPageAnchor,
isOlderPageAnchorSettling,
+ captureNewerPageAnchor,
+ isNewerPageAnchorSettling,
}
}
diff --git a/src/web/src/test/e2e-ui/25-composer-accessory-rail-occupancy.spec.ts b/src/web/src/test/e2e-ui/25-composer-accessory-rail-occupancy.spec.ts
index 72b938ca5..fe5046134 100644
--- a/src/web/src/test/e2e-ui/25-composer-accessory-rail-occupancy.spec.ts
+++ b/src/web/src/test/e2e-ui/25-composer-accessory-rail-occupancy.spec.ts
@@ -15,13 +15,12 @@ test.afterAll(async () => {
expect(restorations.map((result) => result.status)).toEqual(["fulfilled", "fulfilled"])
})
-async function sendExactMessageAndObserve(sender: Page, observer: Page, text: string) {
+async function sendExactMessage(sender: Page, text: string) {
const editable = composerEditable(sender)
await editable.click()
await sender.keyboard.press("ControlOrMeta+A")
await sender.keyboard.press("Backspace")
await sendMessage(sender, text)
- await expect(observer.getByText(text, { exact: true }).first()).toBeVisible()
}
type Rect = {
@@ -37,7 +36,13 @@ type Rect = {
type RailMetrics = {
layout: string | null
rail: Rect | null
- scroller: Rect & { clientHeight: number; scrollTop: number }
+ scroller: Rect & {
+ clientHeight: number
+ scrollHeight: number
+ scrollTop: number
+ firstVisibleId: string | null
+ firstVisibleOffset: number | null
+ }
composer: Rect
typing: Rect | null
center: Rect | null
@@ -52,12 +57,6 @@ type RailMetrics = {
textOverflow: string
whiteSpace: string
} | null
- selectionTypingFit: {
- state: string | null
- slotWidth: number
- pillWidth: number
- visibility: string
- } | null
}
async function railMetrics(page: Page, finalMessageId?: string): Promise<RailMetrics> {
@@ -66,10 +65,11 @@ async function railMetrics(page: Page, finalMessageId?: string): Promise<RailMet
const find = (id: string) => document.querySelector<HTMLElement>(`[data-testid='${id}']`)
const rail = find(ids.rail)
const typing = find(ids.typing)
- const selectionTypingSlot = document.querySelector<HTMLElement>("[data-selection-typing-fit]")
- const selectionTypingPill = selectionTypingSlot?.firstElementChild as HTMLElement | null
const center = find(ids.scroll) ?? find(ids.selection)
const scroller = find(ids.scroller)!
+ const scrollerRect = scroller.getBoundingClientRect()
+ const firstVisible = Array.from(scroller.querySelectorAll<HTMLElement>("[data-msg-id]"))
+ .find((row) => row.getBoundingClientRect().bottom > scrollerRect.top)
const content = document.querySelector<HTMLElement>("[data-message-list-content]")!
const finalMessage = ids.finalMessage ? find(ids.finalMessage) : null
const typingText = typing?.querySelector<HTMLElement>("span.min-w-0.truncate") ?? null
@@ -89,9 +89,14 @@ async function railMetrics(page: Page, finalMessageId?: string): Promise<RailMet
layout: rail?.dataset.layout ?? null,
rail: rail ? toRect(rail.getBoundingClientRect()) : null,
scroller: {
- ...toRect(scroller.getBoundingClientRect()),
+ ...toRect(scrollerRect),
clientHeight: scroller.clientHeight,
+ scrollHeight: scroller.scrollHeight,
scrollTop: scroller.scrollTop,
+ firstVisibleId: firstVisible?.dataset.msgId ?? null,
+ firstVisibleOffset: firstVisible
+ ? firstVisible.getBoundingClientRect().top - scrollerRect.top
+ : null,
},
composer: toRect(find(ids.composer)!.getBoundingClientRect()),
typing: typingVisible ? toRect(typing.getBoundingClientRect()) : null,
@@ -109,14 +114,6 @@ async function railMetrics(page: Page, finalMessageId?: string): Promise<RailMet
whiteSpace: style.whiteSpace,
}
: null,
- selectionTypingFit: selectionTypingSlot && selectionTypingPill
- ? {
- state: selectionTypingSlot.dataset.selectionTypingFit ?? null,
- slotWidth: selectionTypingSlot.getBoundingClientRect().width,
- pillWidth: selectionTypingPill.getBoundingClientRect().width,
- visibility: getComputedStyle(selectionTypingPill).visibility,
- }
- : null,
}
}, {
rail: tid.composerAccessoryRail,
@@ -161,10 +158,22 @@ function expectContained(metrics: RailMetrics, state: string, width: number): vo
}
function expectStableScrollerViewport(before: RailMetrics, after: RailMetrics): void {
- for (const key of ["left", "top", "right", "bottom", "width", "height", "clientHeight"] as const) {
+ for (const key of [
+ "left",
+ "top",
+ "right",
+ "bottom",
+ "width",
+ "height",
+ "clientHeight",
+ "scrollHeight",
+ "scrollTop",
+ ] as const) {
expect(after.scroller[key], `${key}: ${JSON.stringify({ before, after })}`)
.toBe(before.scroller[key])
}
+ expect(after.scroller.firstVisibleId).toBe(before.scroller.firstVisibleId)
+ expect(after.scroller.firstVisibleOffset).toBe(before.scroller.firstVisibleOffset)
}
function expectCheckpoint(
@@ -172,39 +181,32 @@ function expectCheckpoint(
state: string,
width: number,
selection: boolean,
- typing: boolean,
): void {
const evidence = `${state}@${width}: ${JSON.stringify(metrics)}`
const expectedGap = width < 640 ? 8 : 16
- expect(metrics.contentPaddingBottom, evidence).toBe(width < 640 ? 56 : 72)
+ expect(metrics.contentPaddingBottom, evidence).toBe(width < 640 ? 16 : 24)
expect(metrics.scroller.bottom, evidence).toBeLessThanOrEqual(metrics.composer.top + 1)
if (metrics.typing?.width) {
- expect(metrics.typing.height, `typing ${evidence}`).toBe(32)
- expect(metrics.rail, evidence).not.toBeNull()
- expect(metrics.typing.top, evidence).toBeGreaterThanOrEqual(metrics.rail!.top - 1)
- expect(metrics.typing.bottom, evidence).toBeLessThanOrEqual(metrics.rail!.bottom + 1)
+ expect(metrics.typing.height, `typing ${evidence}`).toBe(28)
+ expect(metrics.typing.bottom, evidence).toBeLessThanOrEqual(metrics.scroller.top + 1)
}
if (metrics.center?.width) {
- expect(metrics.rail, evidence).not.toBeNull()
- expect(Math.abs(metrics.scroller.bottom - metrics.center.bottom - expectedGap), evidence)
- .toBeLessThanOrEqual(1)
- expect(metrics.rail!.bottom, evidence).toBeLessThanOrEqual(metrics.scroller.bottom + 1)
- expect(metrics.center.bottom, evidence).toBeLessThanOrEqual(metrics.scroller.bottom + 1)
if (!selection) {
+ expect(metrics.rail, evidence).not.toBeNull()
+ expect(Math.abs(metrics.scroller.bottom - metrics.center.bottom - expectedGap), evidence)
+ .toBeLessThanOrEqual(1)
+ expect(metrics.rail!.bottom, evidence).toBeLessThanOrEqual(metrics.scroller.bottom + 1)
expect(metrics.center.height, `scroll ${evidence}`).toBe(32)
- } else if (width < 640) {
- expect(metrics.center.height, `selection ${evidence}`).toBe(40)
} else {
- expect(metrics.center.height, `selection ${evidence}`).toBe(38)
+ expect(metrics.rail, evidence).toBeNull()
+ expect(metrics.center.top, evidence).toBeGreaterThanOrEqual(metrics.composer.top - 1)
+ expect(metrics.center.bottom, evidence).toBeLessThanOrEqual(metrics.composer.bottom + 1)
+ expect(metrics.center.height, `selection ${evidence}`).toBe(width < 640 ? 40 : 38)
}
}
- const controls = [metrics.typing, metrics.center].filter(
- (control): control is Rect => !!control && control.width > 0,
- )
- if (metrics.finalMessage && controls.length > 0 && (selection || (typing && !metrics.center))) {
- const highestControlTop = Math.min(...controls.map((control) => control.top))
- expect(highestControlTop - metrics.finalMessage.bottom, evidence)
- .toBeGreaterThanOrEqual(expectedGap - 1)
+ if (metrics.finalMessage && metrics.finalMessage.bottom <= metrics.scroller.bottom + 1) {
+ expect(metrics.scroller.bottom - metrics.finalMessage.bottom, evidence)
+ .toBeGreaterThanOrEqual(metrics.contentPaddingBottom - 1)
}
}
@@ -249,14 +251,10 @@ async function captureState(args: {
: rect.left > 1 && Math.abs(rect.right - viewportWidth) <= 1
}, width)).toBe(true)
const rail = page.getByTestId(tid.composerAccessoryRail)
- await expect(rail).toHaveCount(center || typing ? 1 : 0)
- if (center || typing) await expect(rail).toHaveAttribute("data-layout", layout!)
+ await expect(rail).toHaveCount(center && !selection ? 1 : 0)
+ if (center && !selection) await expect(rail).toHaveAttribute("data-layout", layout!)
await expect(page.getByTestId(tid.typingIndicator)).toHaveCount(typing ? 1 : 0)
- if (typing && !selection) await expect(page.getByTestId(tid.typingIndicator)).toBeVisible()
- if (typing && selection) {
- await expect(page.locator("[data-selection-typing-fit]"))
- .toHaveAttribute("data-selection-typing-fit", /^(visible|hidden)$/)
- }
+ if (typing) await expect(page.getByTestId(tid.typingIndicator)).toBeVisible()
await expect(page.getByTestId(tid.messageSelectionToolbar)).toHaveCount(selection ? 1 : 0)
if (selection) {
await expect.poll(() => page.getByTestId(tid.messageSelectionToolbar).evaluate(
@@ -271,22 +269,7 @@ async function captureState(args: {
}
const metrics = await settledRailMetrics(page, finalMessageId)
expectContained(metrics, state, width)
- expectCheckpoint(metrics, state, width, selection, metrics.typing !== null)
- if (selection && typing) {
- const fit = metrics.selectionTypingFit
- expect(fit, `${state}@${width}`).not.toBeNull()
- const shouldFit = fit!.pillWidth <= fit!.slotWidth
- expect(fit!.state, `${state}@${width}: ${JSON.stringify(fit)}`)
- .toBe(shouldFit ? "visible" : "hidden")
- expect(fit!.visibility, `${state}@${width}: ${JSON.stringify(fit)}`)
- .toBe(shouldFit ? "visible" : "hidden")
- expect(metrics.typing === null, `${state}@${width}: ${JSON.stringify(fit)}`)
- .toBe(!shouldFit)
- if (shouldFit) {
- expect(metrics.typingText!.scrollWidth, `${state}@${width}: ${JSON.stringify(metrics)}`)
- .toBeLessThanOrEqual(metrics.typingText!.clientWidth)
- }
- }
+ expectCheckpoint(metrics, state, width, selection)
if (center) {
expect(metrics.center, `${state}@${width}`).not.toBeNull()
expect(Math.abs(metrics.center!.center - metrics.composer.center), `${state}@${width}`)
@@ -348,7 +331,7 @@ async function captureEmptyState(
await expect(page.getByTestId(tid.composerAccessoryRail)).toHaveCount(0)
await expect(page.getByTestId(tid.channelComposerShell)).toBeVisible()
const metrics = await settledRailMetrics(page, finalMessageId)
- expect(metrics.contentPaddingBottom).toBe(width < 640 ? 56 : 72)
+ expect(metrics.contentPaddingBottom).toBe(width < 640 ? 16 : 24)
expect(metrics.scroller.bottom).toBeLessThanOrEqual(metrics.composer.top + 1)
const documentWidths = await page.evaluate(() => ({
client: document.documentElement.clientWidth,
@@ -362,6 +345,19 @@ async function captureEmptyState(
}
}
+async function settleAwayAtTop(page: Page): Promise<void> {
+ const scrollRoot = page.getByTestId(tid.messageScroller)
+ await expect.poll(() => scrollRoot.evaluate(async (element) => {
+ element.scrollTop = 0
+ element.dispatchEvent(new Event("scroll"))
+ await new Promise<void>((resolve) => {
+ requestAnimationFrame(() => requestAnimationFrame(() => resolve()))
+ })
+ return element.scrollTop
+ })).toBe(0)
+ await expect(page.getByTestId(tid.scrollToPresent)).toBeVisible()
+}
+
test("composer accessory rail reallocates every occupied slot without overflow", async ({ asUser }, testInfo) => {
test.setTimeout(180_000)
const serverId = await seedServer("alice", `Rail occupancy ${Date.now()}`)
@@ -393,16 +389,8 @@ test("composer accessory rail reallocates every occupied slot without overflow",
await expect(composerEditable(bob.page)).toBeVisible()
await expect(composerEditable(carol.page)).toBeVisible()
- const ping = `rail ws ready ${Date.now()}`
- await sendMessage(bob.page, ping)
- const finalMessage = alice.page.getByText(ping, { exact: true })
- await expect(finalMessage).toBeVisible()
- const finalMessageId = await finalMessage.evaluate((element, messageTestIdPrefix) => {
- const testId = element.closest(`[data-testid^="${messageTestIdPrefix}"]`)
- ?.getAttribute("data-testid")
- if (!testId) throw new Error("final WS message row has no test id")
- return testId.slice(messageTestIdPrefix.length)
- }, tid.message(""))
+ const finalMessageId = selectableMessageId
+ await expect(alice.page.getByTestId(tid.message(finalMessageId))).toBeVisible()
const scrollRoot = alice.page.getByTestId(tid.messageScroller)
await expect.poll(() => scrollRoot.evaluate((element) => element.scrollHeight > element.clientHeight))
@@ -436,7 +424,7 @@ test("composer accessory rail reallocates every occupied slot without overflow",
})
await expect(alice.page.getByTestId(tid.scrollToPresent)).toBeVisible()
- const centerOnly = await captureState({
+ await captureState({
page: alice.page,
testInfo,
state: "c-only",
@@ -446,6 +434,10 @@ test("composer accessory rail reallocates every occupied slot without overflow",
finalMessageId,
})
+ await alice.page.setViewportSize({ width: 390, height: 844 })
+ await settleAwayAtTop(alice.page)
+ const beforeTyping = await settledRailMetrics(alice.page, finalMessageId)
+
const bobEditor = composerEditable(bob.page)
await bobEditor.click()
await bob.page.keyboard.press("ControlOrMeta+A")
@@ -453,8 +445,10 @@ test("composer accessory rail reallocates every occupied slot without overflow",
await bob.page.keyboard.type("typing occupancy")
await expect(alice.page.getByTestId(tid.typingIndicator))
.toContainText(LONG_TYPING_NAME, { timeout: 20_000 })
+ const afterTyping = await settledRailMetrics(alice.page, finalMessageId)
+ expectStableScrollerViewport(beforeTyping, afterTyping)
- const typingAndCenter = await captureState({
+ await captureState({
page: alice.page,
testInfo,
state: "l-c",
@@ -463,9 +457,6 @@ test("composer accessory rail reallocates every occupied slot without overflow",
typing: true,
finalMessageId,
})
- for (const width of VIEWPORT_WIDTHS) {
- expectStableScrollerViewport(centerOnly[width], typingAndCenter[width])
- }
await alice.page.getByTestId(tid.typingIndicator).evaluate((element) => {
element.setAttribute("data-e2e-node-identity", "typing-survived")
@@ -480,19 +471,18 @@ test("composer accessory rail reallocates every occupied slot without overflow",
page: alice.page,
testInfo,
state: "l-only",
- layout: "left-only",
+ layout: null,
center: false,
typing: true,
finalMessageId,
})
- expect(leftOnly[320].typingText?.overflowX).toBe("hidden")
- expect(leftOnly[320].typingText?.textOverflow).toBe("ellipsis")
- expect(leftOnly[320].typingText?.whiteSpace).toBe("nowrap")
- expect(leftOnly[320].typingText!.scrollWidth).toBeGreaterThan(leftOnly[320].typingText!.clientWidth)
+ for (const width of VIEWPORT_WIDTHS) {
+ expect(leftOnly[width].rail).toBeNull()
+ expect(leftOnly[width].typing).not.toBeNull()
+ }
- await sendExactMessageAndObserve(
+ await sendExactMessage(
bob.page,
- alice.page,
`long typing clear ${Date.now()}`,
)
await expect(alice.page.getByTestId(tid.typingIndicator)).toHaveCount(0)
@@ -518,13 +508,9 @@ test("composer accessory rail reallocates every occupied slot without overflow",
selection: true,
finalMessageId,
})
- const shortFitStates = VIEWPORT_WIDTHS.map(
- (width) => selectionShort[width].selectionTypingFit?.state,
- )
- expect(shortFitStates).toContain("visible")
- expect(shortFitStates).toContain("hidden")
for (const width of VIEWPORT_WIDTHS) {
expect(selectionShort[width].center!.center).toBe(selectionNone[width].center!.center)
+ expect(selectionShort[width].typing).not.toBeNull()
}
await bobEditor.click()
@@ -550,14 +536,12 @@ test("composer accessory rail reallocates every occupied slot without overflow",
expect(selectionMultiple[width].center!.center).toBe(selectionNone[width].center!.center)
}
- await sendExactMessageAndObserve(
+ await sendExactMessage(
bob.page,
- alice.page,
`multiple typing clear ${Date.now()}`,
)
- await sendExactMessageAndObserve(
+ await sendExactMessage(
carol.page,
- alice.page,
`short typing clear ${Date.now()}`,
)
await expect(alice.page.getByTestId(tid.typingIndicator)).toHaveCount(0)
@@ -580,13 +564,11 @@ test("composer accessory rail reallocates every occupied slot without overflow",
finalMessageId,
})
for (const width of [390, 639, 640, 1280] as const) {
- expect(selectionLong[width].selectionTypingFit?.state).toBe("hidden")
- expect(selectionLong[width].typing).toBeNull()
+ expect(selectionLong[width].typing).not.toBeNull()
}
- await sendExactMessageAndObserve(
+ await sendExactMessage(
bob.page,
- alice.page,
`theme typing clear ${Date.now()}`,
)
await expect(alice.page.getByTestId(tid.typingIndicator)).toHaveCount(0)
@@ -609,7 +591,7 @@ test("composer accessory rail reallocates every occupied slot without overflow",
element.dispatchEvent(new Event("scroll"))
})
await expect(alice.page.getByTestId(tid.scrollToPresent)).toBeVisible()
- const settledCenter = await captureState({
+ await captureState({
page: alice.page,
testInfo,
state: "settled-center",
@@ -618,9 +600,6 @@ test("composer accessory rail reallocates every occupied slot without overflow",
typing: false,
finalMessageId,
})
- for (const width of VIEWPORT_WIDTHS) {
- expectStableScrollerViewport(centerOnly[width], settledCenter[width])
- }
await scrollRoot.evaluate((element) => {
element.scrollTop = element.scrollHeight
diff --git a/src/web/src/test/e2e-ui/38-community-navigation-checkpoint-matrix.spec.ts b/src/web/src/test/e2e-ui/38-community-navigation-checkpoint-matrix.spec.ts
index eeb1f37ab..44c7ba3c4 100644
--- a/src/web/src/test/e2e-ui/38-community-navigation-checkpoint-matrix.spec.ts
+++ b/src/web/src/test/e2e-ui/38-community-navigation-checkpoint-matrix.spec.ts
@@ -243,10 +243,13 @@ test("mobile route commits stay stationary while sidebar identity survives same-
).__e2eDndOwner)).toBe("stable")
await clearSurfaceAnimations(page)
+ const pendingPath = `/c/channels/${serverId}/${pendingChannel}`
+ const pendingGate = await holdRoute(page, pendingPath)
await page.getByTestId(tid.channelRow(pendingChannel)).click({ noWaitAfter: true })
+ await expect.poll(pendingGate.held).toBeGreaterThan(0)
await expect(page.getByTestId(tid.pendingMain("server-conversation"))).toBeVisible()
+ await pendingGate.release()
- const pendingPath = `/c/channels/${serverId}/${pendingChannel}`
await expect.poll(() => new URL(page.url()).pathname).toBe(pendingPath)
await expect(page.getByTestId(tid.composerInput)).toBeVisible({ timeout: 30_000 })
expect(await surfaceAnimations(page)).toEqual([])
diff --git a/src/web/src/test/e2e-ui/39-mobile-message-interactions.spec.ts b/src/web/src/test/e2e-ui/39-mobile-message-interactions.spec.ts
index 37fc1d98d..65235f179 100644
--- a/src/web/src/test/e2e-ui/39-mobile-message-interactions.spec.ts
+++ b/src/web/src/test/e2e-ui/39-mobile-message-interactions.spec.ts
@@ -40,7 +40,10 @@ type ScrollerGeometry = {
bottom: number
height: number
clientHeight: number
+ scrollHeight: number
scrollTop: number
+ firstVisibleId: string | null
+ firstVisibleOffset: number | null
}
async function settledScrollerGeometry(page: Page): Promise<ScrollerGeometry> {
@@ -50,12 +53,19 @@ async function settledScrollerGeometry(page: Page): Promise<ScrollerGeometry> {
await expect.poll(async () => {
const current = await scroller.evaluate((element) => {
const rect = element.getBoundingClientRect()
+ const firstVisible = Array.from(element.querySelectorAll<HTMLElement>("[data-msg-id]"))
+ .find((row) => row.getBoundingClientRect().bottom > rect.top)
return {
top: rect.top,
bottom: rect.bottom,
height: rect.height,
clientHeight: element.clientHeight,
+ scrollHeight: element.scrollHeight,
scrollTop: element.scrollTop,
+ firstVisibleId: firstVisible?.dataset.msgId ?? null,
+ firstVisibleOffset: firstVisible
+ ? firstVisible.getBoundingClientRect().top - rect.top
+ : null,
}
})
const signature = JSON.stringify(current)
@@ -68,10 +78,17 @@ async function settledScrollerGeometry(page: Page): Promise<ScrollerGeometry> {
}
function expectStableScroller(before: ScrollerGeometry, after: ScrollerGeometry): void {
- for (const key of ["top", "bottom", "height", "clientHeight", "scrollTop"] as const) {
+ for (const key of ["top", "bottom", "height", "clientHeight", "scrollHeight", "scrollTop"] as const) {
expect(Math.abs(after[key] - before[key]), `${key}: ${JSON.stringify({ before, after })}`)
.toBeLessThanOrEqual(1)
}
+ expect(after.firstVisibleId).toBe(before.firstVisibleId)
+ if (before.firstVisibleOffset === null || after.firstVisibleOffset === null) {
+ expect(after.firstVisibleOffset).toBe(before.firstVisibleOffset)
+ } else {
+ expect(Math.abs(after.firstVisibleOffset - before.firstVisibleOffset))
+ .toBeLessThanOrEqual(1)
+ }
}
async function dispatchSwipe(
@@ -495,8 +512,8 @@ test("mobile reply, avatar mention, and typing rail keep exact backend and WS id
composerId: tid.channelComposerShell,
})
expect(restingThreadGap).not.toBeNull()
- expect(restingThreadGap!).toBeGreaterThanOrEqual(55)
- expect(restingThreadGap!).toBeLessThanOrEqual(58)
+ expect(restingThreadGap!).toBeGreaterThanOrEqual(15)
+ expect(restingThreadGap!).toBeLessThanOrEqual(18)
const threadWsReadyId = await seedMessage("alice", threadId, `thread ws ready ${stamp}`)
await expect.poll(() => bobProxy.frames.some((frame) => (
frameHasMessage(frame, threadId, threadWsReadyId)
@@ -629,12 +646,11 @@ test("mobile reply, avatar mention, and typing rail keep exact backend and WS id
indicatorId: tid.typingIndicator,
replyMessageTestId: tid.message(typingWsReadyId),
})
- expect(geometry.contentPaddingBottom).toBe(56)
+ expect(geometry.contentPaddingBottom).toBe(16)
expect(geometry.scroller!.bottom).toBeLessThanOrEqual(geometry.composer!.top + 1)
- expect(geometry.rail!.bottom).toBeLessThanOrEqual(geometry.scroller!.bottom + 1)
- expect(geometry.indicator!.top).toBeGreaterThanOrEqual(geometry.rail!.top - 1)
- expect(geometry.indicator!.bottom).toBeLessThanOrEqual(geometry.rail!.bottom + 1)
- expect(geometry.indicator!.top - geometry.finalMessage!.bottom).toBeGreaterThanOrEqual(7)
+ expect(geometry.rail).toBeNull()
+ expect(geometry.indicator!.bottom).toBeLessThanOrEqual(geometry.scroller!.top + 1)
+ expect(geometry.scroller!.bottom - geometry.finalMessage!.bottom).toBeGreaterThanOrEqual(15)
expect(geometry.finalMessage!.bottom).toBeLessThanOrEqual(geometry.scroller!.bottom + 1)
expect(geometry.horizontalOverflow).toBeLessThanOrEqual(0)
@@ -660,12 +676,13 @@ test("mobile reply, avatar mention, and typing rail keep exact backend and WS id
})
expect(scrollTypingGeometry.rail!.bottom).toBeLessThanOrEqual(scrollTypingGeometry.scroller!.bottom + 1)
expect(scrollTypingGeometry.scroll!.bottom).toBeLessThanOrEqual(scrollTypingGeometry.scroller!.bottom + 1)
- expect(scrollTypingGeometry.indicator!.top).toBeGreaterThanOrEqual(scrollTypingGeometry.rail!.top - 1)
+ expect(scrollTypingGeometry.indicator!.bottom).toBeLessThanOrEqual(scrollTypingGeometry.scroller!.top + 1)
await alice.page.getByTestId(tid.scrollToPresent).click()
await expect(alice.page.getByTestId(tid.scrollToPresent)).toHaveCount(0)
await bobEditable.pressSequentially(" selection")
await expect(alice.page.getByTestId(tid.typingIndicator)).toBeVisible({ timeout: 4_000 })
+ const channelScrollerBeforeSelection = await settledScrollerGeometry(alice.page)
const finalChannelMessage = alice.page.getByTestId(tid.message(typingWsReadyId))
await finalChannelMessage.getByText(`typing ws ready ${stamp}`, { exact: true }).tap()
const shareAsImage = await expectTouchActionMenu(
@@ -675,14 +692,11 @@ test("mobile reply, avatar mention, and typing rail keep exact backend and WS id
)
await shareAsImage.click({ timeout: 3_000 })
await expect(alice.page.getByTestId(tid.messageSelectionToolbar)).toBeVisible()
- await expect(alice.page.locator("[data-selection-typing-fit]"))
- .toHaveAttribute("data-selection-typing-fit", /^(visible|hidden)$/)
+ const channelScrollerDuringSelection = await settledScrollerGeometry(alice.page)
+ expectStableScroller(channelScrollerBeforeSelection, channelScrollerDuringSelection)
const selectionTypingGeometry = await alice.page.evaluate((ids) => {
const rect = (element: Element | null) => element?.getBoundingClientRect() ?? null
- const typingSlot = document.querySelector<HTMLElement>("[data-selection-typing-fit]")
- const typingPill = typingSlot?.firstElementChild as HTMLElement | null
const typingIndicator = document.querySelector<HTMLElement>(`[data-testid="${ids.indicator}"]`)
- const typingText = typingIndicator?.querySelector<HTMLElement>("span.min-w-0.truncate")
return {
finalMessage: rect(document.querySelector(`[data-testid="${ids.finalMessage}"]`)),
scroller: rect(document.querySelector(`[data-testid="${ids.scroller}"]`)),
@@ -690,16 +704,6 @@ test("mobile reply, avatar mention, and typing rail keep exact backend and WS id
selection: rect(document.querySelector(`[data-testid="${ids.selection}"]`)),
indicator: rect(typingIndicator),
composer: rect(document.querySelector(`[data-testid="${ids.composer}"]`)),
- typingFit: typingSlot && typingPill && typingIndicator && typingText
- ? {
- state: typingSlot.dataset.selectionTypingFit,
- slotWidth: typingSlot.getBoundingClientRect().width,
- pillWidth: typingPill.getBoundingClientRect().width,
- visibility: getComputedStyle(typingIndicator).visibility,
- textClientWidth: typingText.clientWidth,
- textScrollWidth: typingText.scrollWidth,
- }
- : null,
}
}, {
finalMessage: tid.message(typingWsReadyId),
@@ -709,24 +713,16 @@ test("mobile reply, avatar mention, and typing rail keep exact backend and WS id
indicator: tid.typingIndicator,
composer: tid.channelComposerShell,
})
- expect(selectionTypingGeometry.selection!.top - selectionTypingGeometry.finalMessage!.bottom)
- .toBeGreaterThanOrEqual(7)
- expect(selectionTypingGeometry.rail!.bottom).toBeLessThanOrEqual(selectionTypingGeometry.scroller!.bottom + 1)
- expect(selectionTypingGeometry.selection!.bottom).toBeLessThanOrEqual(selectionTypingGeometry.scroller!.bottom + 1)
+ expect(selectionTypingGeometry.rail).toBeNull()
+ expect(selectionTypingGeometry.selection!.top).toBeGreaterThanOrEqual(selectionTypingGeometry.composer!.top - 1)
+ expect(selectionTypingGeometry.selection!.bottom).toBeLessThanOrEqual(selectionTypingGeometry.composer!.bottom + 1)
expect(selectionTypingGeometry.scroller!.bottom).toBeLessThanOrEqual(selectionTypingGeometry.composer!.top + 1)
expect(selectionTypingGeometry.finalMessage!.bottom).toBeLessThanOrEqual(selectionTypingGeometry.scroller!.bottom + 1)
- expect(selectionTypingGeometry.typingFit).not.toBeNull()
- const selectionTypingFits = selectionTypingGeometry.typingFit!.pillWidth
- <= selectionTypingGeometry.typingFit!.slotWidth
- expect(selectionTypingGeometry.typingFit!.state)
- .toBe(selectionTypingFits ? "visible" : "hidden")
- expect(selectionTypingGeometry.typingFit!.visibility)
- .toBe(selectionTypingFits ? "visible" : "hidden")
- if (selectionTypingFits) {
- expect(selectionTypingGeometry.typingFit!.textScrollWidth)
- .toBeLessThanOrEqual(selectionTypingGeometry.typingFit!.textClientWidth)
- }
+ expect(selectionTypingGeometry.indicator!.bottom)
+ .toBeLessThanOrEqual(selectionTypingGeometry.scroller!.top + 1)
await alice.page.getByRole("button", { name: "Cancel message selection" }).click()
+ const channelScrollerAfterSelection = await settledScrollerGeometry(alice.page)
+ expectStableScroller(channelScrollerBeforeSelection, channelScrollerAfterSelection)
await bobEditable.fill("")
await expect(alice.page.getByTestId(tid.typingIndicator)).toBeHidden({ timeout: 15_000 })
@@ -816,10 +812,10 @@ test("mobile reply, avatar mention, and typing rail keep exact backend and WS id
railId: tid.composerAccessoryRail,
indicatorId: tid.typingIndicator,
})
- expect(dmGeometry.contentPaddingBottom).toBe(56)
+ expect(dmGeometry.contentPaddingBottom).toBe(16)
expect(dmGeometry.scroller!.bottom).toBeLessThanOrEqual(dmGeometry.composer!.top + 1)
- expect(dmGeometry.rail!.bottom).toBeLessThanOrEqual(dmGeometry.scroller!.bottom + 1)
- expect(dmGeometry.indicator!.bottom).toBeLessThanOrEqual(dmGeometry.rail!.bottom + 1)
+ expect(dmGeometry.rail).toBeNull()
+ expect(dmGeometry.indicator!.bottom).toBeLessThanOrEqual(dmGeometry.scroller!.top + 1)
expect(dmGeometry.horizontalOverflow).toBeLessThanOrEqual(0)
await bobDmEditable.fill("")
await expect(alice.page.getByTestId(tid.typingIndicator)).toBeHidden({ timeout: 15_000 })
diff --git a/src/web/src/test/e2e-ui/55-message-scroll-characterization.spec.ts b/src/web/src/test/e2e-ui/55-message-scroll-characterization.spec.ts
index 0763af200..b64f8d1d4 100644
--- a/src/web/src/test/e2e-ui/55-message-scroll-characterization.spec.ts
+++ b/src/web/src/test/e2e-ui/55-message-scroll-characterization.spec.ts
@@ -1,11 +1,19 @@
import type { Locator, Page, Route, TestInfo } from "@playwright/test"
-import { test, expect, sessionCookie } from "./_fixtures/community-fixture"
+import { test, expect, sessionCookie, userId } from "./_fixtures/community-fixture"
import { composerEditable, gotoAfterUserWsAuth, sendMessage } from "./_fixtures/actions"
import {
communityFrameEvents,
proxyCommunityWebSockets,
} from "./_fixtures/community-ws-proxy"
-import { seedChannel, seedJoinServer, seedMessage, seedServer, seedThread } from "./_fixtures/seed"
+import {
+ seedChannel,
+ seedDm,
+ seedDmMessage,
+ seedJoinServer,
+ seedMessage,
+ seedServer,
+ seedThread,
+} from "./_fixtures/seed"
import {
abortScrollTrace,
attachScrollTrace,
@@ -113,6 +121,21 @@ async function seedProfile(
return { ids, estimates }
}
+async function seedDmProfile(
+ dmId: string,
+ count: number,
+): Promise<{ ids: string[]; estimates: Record<string, number> }> {
+ const ids: string[] = []
+ const estimates: Record<string, number> = {}
+ for (let index = 0; index < count; index += 1) {
+ const content = profileContent(index)
+ const id = await seedDmMessage("alice", dmId, content)
+ ids.push(id)
+ estimates[id] = estimatePlainMessage(content)
+ }
+ return { ids, estimates }
+}
+
async function setReadCheckpoint(channelId: string, messageId: string): Promise<void> {
const response = await fetch(`${WEB_URL}/api/community/channels/${channelId}/read`, {
method: "PUT",
@@ -311,7 +334,7 @@ async function readMessageViewportGeometry(scroller: Locator): Promise<MessageVi
const content = root.querySelector<HTMLElement>("[data-message-list-content]")
const rail = boundary?.querySelector<HTMLElement>(`[data-testid="${accessoryRailTestId}"]`)
const railRect = rail?.getBoundingClientRect() ?? null
- const composer = surface?.querySelector<HTMLElement>('[data-slot="community-composer-overlay"]')
+ const composer = surface?.querySelector<HTMLElement>('[data-slot="community-conversation-footer"]')
const composerRect = composer?.getBoundingClientRect() ?? null
return {
scrollTop: root.scrollTop,
@@ -366,15 +389,24 @@ function expectViewportAnchorPreserved(
).toBeLessThanOrEqual(1)
}
-function expectAwayLatchPreserved(
+function expectResizeAnchorPreserved(
+ before: MessageViewportGeometry,
after: MessageViewportGeometry,
+ distance: number,
label: string,
): void {
- expect(after.distanceToEnd, `${label}: remains away`).toBeGreaterThan(1)
+ if (distance <= 100) {
+ expect(
+ Math.abs(after.distanceToEnd - before.distanceToEnd),
+ `${label}: distance to tail`,
+ ).toBeLessThanOrEqual(1)
+ return
+ }
+ expectViewportAnchorPreserved(before, after, label)
}
-function expectFixedMessageGeometry(geometry: MessageViewportGeometry, label: string): void {
- expect(geometry.contentPaddingBottom, `${label}: desktop tail safe area`).toBe(72)
+function expectInFlowMessageGeometry(geometry: MessageViewportGeometry, label: string): void {
+ expect(geometry.contentPaddingBottom, `${label}: desktop normal tail inset`).toBe(24)
expect(geometry.composerRect, `${label}: scoped composer`).not.toBeNull()
if (geometry.railRect) {
expect(geometry.railPosition, `${label}: rail position`).toBe("absolute")
@@ -403,9 +435,11 @@ test.describe.serial("message scroll characterization", () => {
let loadingChannelId: string
let upwardChannelId: string
let composerChannelId: string
+ let composerDmId: string
let loadingProfile: Awaited<ReturnType<typeof seedProfile>>
let upwardProfile: Awaited<ReturnType<typeof seedProfile>>
let composerProfile: Awaited<ReturnType<typeof seedProfile>>
+ let composerDmProfile: Awaited<ReturnType<typeof seedDmProfile>>
test.beforeAll(async () => {
test.setTimeout(240_000)
@@ -417,9 +451,11 @@ test.describe.serial("message scroll characterization", () => {
loadingChannelId = await seedChannel("alice", serverId, `scroll-loading-${stamp}`)
upwardChannelId = await seedChannel("alice", serverId, `scroll-upward-${stamp}`)
composerChannelId = await seedChannel("alice", serverId, `scroll-composer-${stamp}`)
+ composerDmId = await seedDm("alice", userId("bob"))
loadingProfile = await seedProfile(loadingChannelId, 130, false, "rotate", 64)
upwardProfile = await seedProfile(upwardChannelId, 72, false, "rotate", 23)
composerProfile = await seedProfile(composerChannelId, 36, true, "alice")
+ composerDmProfile = await seedDmProfile(composerDmId, 36)
})
test("cold and warm loading, older prepend, and jump-to-present remain observable", async ({ asUser }, testInfo) => {
@@ -818,7 +854,101 @@ test.describe.serial("message scroll characterization", () => {
expect(messageCreateCount(proxy.frames, composerChannelId, awaySend)).toBe(1)
})
- test("exact-pinned composer and accessory resizes preserve geometry boundaries", async ({ asUser }, testInfo) => {
+ test("DM composer clear preserves pinned and away viewport geometry", async ({ asUser }, testInfo) => {
+ test.setTimeout(180_000)
+ const alice = await asUser("alice")
+ await alice.page.setViewportSize(VIEWPORT)
+ await installScrollTrace(alice.page)
+ const proxy = await proxyCommunityWebSockets(alice.context)
+ let messagePosts = 0
+ alice.page.on("request", (request) => {
+ if (
+ request.method() === "POST"
+ && new URL(request.url()).pathname === `/api/community/channels/${composerDmId}/messages`
+ ) messagePosts += 1
+ })
+ await gotoAfterUserWsAuth(alice.page, `/c/me/${composerDmId}`)
+ const scroller = alice.page.getByTestId(tid.messageScroller)
+ const editable = composerEditable(alice.page)
+ await expect(editable).toBeVisible()
+ await expect(alice.page.getByTestId(tid.message(composerDmProfile.ids.at(-1)!)))
+ .toBeVisible({ timeout: 30_000 })
+ await scroller.evaluate((element) => {
+ element.scrollTop = element.scrollHeight
+ element.dispatchEvent(new Event("scroll"))
+ })
+ const tailGeometry = await alice.page.evaluate(({ scrollerId, messageId }) => {
+ const scrollerElement = document.querySelector<HTMLElement>(
+ `[data-testid="${scrollerId}"]`,
+ )!
+ const content = scrollerElement.querySelector<HTMLElement>("[data-message-list-content]")!
+ const finalMessage = document.querySelector<HTMLElement>(`[data-testid="${messageId}"]`)!
+ const composer = document.querySelector<HTMLElement>('[data-onboarding-target="dm-composer"]')!
+ return {
+ paddingBottom: Number.parseFloat(getComputedStyle(content).paddingBottom),
+ tailGap: scrollerElement.getBoundingClientRect().bottom
+ - finalMessage.getBoundingClientRect().bottom,
+ scrollerBottom: scrollerElement.getBoundingClientRect().bottom,
+ composerTop: composer.getBoundingClientRect().top,
+ }
+ }, {
+ scrollerId: tid.messageScroller,
+ messageId: tid.message(composerDmProfile.ids.at(-1)!),
+ })
+ expect(tailGeometry.paddingBottom).toBe(24)
+ expect(tailGeometry.tailGap).toBeGreaterThanOrEqual(23)
+ expect(tailGeometry.tailGap).toBeLessThanOrEqual(25)
+ expect(tailGeometry.scrollerBottom).toBeLessThanOrEqual(tailGeometry.composerTop + 1)
+ await startScrollTrace(alice.page, {
+ scenario: "dm-composer-clear-viewport",
+ identity: identity(composerDmId),
+ estimatedSizes: composerDmProfile.estimates,
+ })
+
+ const composerLines = (prefix: string) => Array.from(
+ { length: 6 },
+ (_, line) => `${prefix} line ${line} ${"content ".repeat(8)}`,
+ ).join("\n")
+
+ for (const distance of [0, 2, 100, 300]) {
+ await editable.fill(composerLines(`dm-${distance}`))
+ const precondition = distance === 0
+ ? await establishExactPinnedPrecondition(scroller, `dm-composer-${distance}`, 0)
+ : await establishScrollDistancePrecondition(scroller, `dm-composer-${distance}`, distance)
+ await markScrollTrace(alice.page, `dm-composer-${distance}-precondition`, {
+ detail: precondition,
+ })
+ const before = await waitForCommittedGeometry(scroller)
+ expectInFlowMessageGeometry(before, `dm-${distance}-before`)
+ expect(before.surfaceChannelId).toBe(composerDmId)
+
+ await beginScrollTraceAnalysis(alice.page, `dm-composer-shrink-${distance}`)
+ await editable.click()
+ await alice.page.keyboard.press("ControlOrMeta+A")
+ await alice.page.keyboard.press("Backspace")
+ await expect(editable).toHaveText("")
+ await expect.poll(() => scroller.evaluate((element) => element.clientHeight))
+ .toBeGreaterThan(before.clientHeight)
+ const after = await waitForCommittedGeometry(scroller)
+ expectInFlowMessageGeometry(after, `dm-${distance}-after`)
+ expectResizeAnchorPreserved(before, after, distance, `dm-${distance}-after`)
+ await endScrollTraceAnalysis(alice.page, `dm-composer-shrink-${distance}`)
+ await advanceScrollTraceFrame(scroller)
+ }
+
+ const trace = await finishAndAttach(alice.page, testInfo)
+ const segments = new Map(
+ summarizeScrollTrace(trace).analysisSegments.map((segment) => [segment.name, segment]),
+ )
+ for (const distance of [0, 2, 100, 300]) {
+ expect(segments.get(`dm-composer-shrink-${distance}`)).toBeDefined()
+ }
+ expect(messagePosts).toBe(0)
+ expect(proxy.frames.flatMap(communityFrameEvents).filter((event) =>
+ event.type === "community:message.create" && event.channelId === composerDmId)).toHaveLength(0)
+ })
+
+ test("normal-flow composer resizes preserve semantic anchors and interaction boundaries", async ({ asUser }, testInfo) => {
test.setTimeout(180_000)
const splitThreadId = await seedThread(
"alice",
@@ -858,14 +988,10 @@ test.describe.serial("message scroll characterization", () => {
(_, line) => `${prefix} line ${line} ${"content ".repeat(8)}`,
).join("\n")
- for (const distance of [0, 1, 2, 99, 100, 101, 300]) {
- await editable.fill(composerLines(`boundary-${distance}`, 6))
- const precondition = distance <= 1
- ? await establishExactPinnedPrecondition(
- scroller,
- `composer-resize-${distance}`,
- distance as 0 | 1,
- )
+ for (const distance of [0, 2, 100, 300]) {
+ await editable.fill(composerLines(`boundary-${distance}`, 8))
+ const precondition = distance === 0
+ ? await establishExactPinnedPrecondition(scroller, `composer-resize-${distance}`, 0)
: await establishScrollDistancePrecondition(
scroller,
`composer-resize-${distance}`,
@@ -875,7 +1001,7 @@ test.describe.serial("message scroll characterization", () => {
detail: precondition,
})
const before = await waitForCommittedGeometry(scroller)
- expectFixedMessageGeometry(before, `resize-${distance}-before`)
+ expectInFlowMessageGeometry(before, `resize-${distance}-before`)
// Match the user journey that exposed the regression: grow the composer,
// establish the reading position, then delete the draft. Positioning the
@@ -886,30 +1012,25 @@ test.describe.serial("message scroll characterization", () => {
await alice.page.keyboard.press("Backspace")
await expect(editable).toHaveText("")
await expect.poll(() => scroller.evaluate((element) => element.clientHeight))
- .toBe(before.clientHeight)
+ .toBeGreaterThan(before.clientHeight)
const shrunk = await waitForCommittedGeometry(scroller)
- expectFixedMessageGeometry(shrunk, `resize-${distance}-shrunk`)
- expectViewportAnchorPreserved(before, shrunk, `resize-${distance}-shrunk`)
- if (distance <= 1) {
- expect(shrunk.distanceToEnd, `resize-${distance}-shrunk pinned`).toBeLessThanOrEqual(1)
- }
+ expectInFlowMessageGeometry(shrunk, `resize-${distance}-shrunk`)
+ expectResizeAnchorPreserved(before, shrunk, distance, `resize-${distance}-shrunk`)
await endScrollTraceAnalysis(alice.page, `composer-shrink-${distance}`)
await advanceScrollTraceFrame(scroller)
await beginScrollTraceAnalysis(alice.page, `composer-grow-${distance}`)
- await editable.fill(composerLines(`boundary-${distance}`, 6))
+ await editable.fill(composerLines(`boundary-${distance}`, 8))
await expect.poll(() => scroller.evaluate((element) => element.clientHeight))
- .toBe(shrunk.clientHeight)
+ .toBe(before.clientHeight)
const grown = await waitForCommittedGeometry(scroller)
- expectFixedMessageGeometry(grown, `resize-${distance}-grown`)
- expectViewportAnchorPreserved(before, grown, `resize-${distance}-grown`)
- if (distance <= 1) {
- expect(grown.distanceToEnd, `resize-${distance}-grown pinned`).toBeLessThanOrEqual(1)
- }
+ expectInFlowMessageGeometry(grown, `resize-${distance}-grown`)
+ expectResizeAnchorPreserved(before, grown, distance, `resize-${distance}-grown`)
await endScrollTraceAnalysis(alice.page, `composer-grow-${distance}`)
await advanceScrollTraceFrame(scroller)
}
+ await editable.fill("")
const rapidPrecondition = await establishScrollDistancePrecondition(scroller, "rapid-resize-away", 2)
await markScrollTrace(alice.page, "rapid-resize-away-precondition", { detail: rapidPrecondition })
await beginScrollTraceAnalysis(alice.page, "rapid-composer-resizes")
@@ -922,9 +1043,9 @@ test.describe.serial("message scroll characterization", () => {
const rapidShrinkOne = await waitForCommittedGeometry(scroller)
await editable.fill("")
const rapidShrinkTwo = await waitForCommittedGeometry(scroller)
- expect(rapidGrowOne.clientHeight).toBe(rapidBase.clientHeight)
- expect(rapidGrowTwo.clientHeight).toBe(rapidBase.clientHeight)
- expect(rapidShrinkOne.clientHeight).toBe(rapidBase.clientHeight)
+ expect(rapidGrowOne.clientHeight).toBeLessThan(rapidBase.clientHeight)
+ expect(rapidGrowTwo.clientHeight).toBeLessThan(rapidGrowOne.clientHeight)
+ expect(rapidShrinkOne.clientHeight).toBe(rapidGrowOne.clientHeight)
expect(rapidShrinkTwo.clientHeight).toBe(rapidBase.clientHeight)
for (const [label, geometry] of [
["grow-one", rapidGrowOne],
@@ -932,40 +1053,71 @@ test.describe.serial("message scroll characterization", () => {
["shrink-one", rapidShrinkOne],
["shrink-two", rapidShrinkTwo],
] as const) {
- expectAwayLatchPreserved(geometry, `rapid-${label}`)
- expectViewportAnchorPreserved(rapidBase, geometry, `rapid-${label}`)
- expectFixedMessageGeometry(geometry, `rapid-${label}`)
+ expectResizeAnchorPreserved(rapidBase, geometry, 2, `rapid-${label}`)
+ expectInFlowMessageGeometry(geometry, `rapid-${label}`)
}
await endScrollTraceAnalysis(alice.page, "rapid-composer-resizes")
await advanceScrollTraceFrame(scroller)
+ const selectionDraft = composerLines("selection-draft", 8)
+ await editable.fill(selectionDraft)
+ await establishScrollDistancePrecondition(scroller, "selection-footer-away", 300)
+ const selectionBase = await waitForCommittedGeometry(scroller)
+ const selectionTargetId = selectionBase.firstVisibleId!
+ const selectionTarget = alice.page.getByTestId(tid.message(selectionTargetId))
+ await beginScrollTraceAnalysis(alice.page, "selection-footer-away")
+ await selectionTarget.locator("div.group").first().dispatchEvent("pointerover", {
+ pointerId: 1,
+ pointerType: "mouse",
+ isPrimary: true,
+ })
+ const selectionAction = alice.page.getByTestId(tid.messageShare(selectionTargetId))
+ await expect(selectionAction).toBeVisible()
+ await selectionAction.evaluate((button) => (button as HTMLButtonElement).click())
+ await expect(alice.page.getByTestId(tid.messageSelectionToolbar)).toBeVisible()
+ const selectionOpen = await waitForCommittedGeometry(scroller)
+ expect(selectionOpen.clientHeight).toBeGreaterThan(selectionBase.clientHeight)
+ expect(selectionOpen.scrollHeight).toBe(selectionBase.scrollHeight)
+ expectViewportAnchorPreserved(selectionBase, selectionOpen, "selection-open-away")
+ await expect(editable).toContainText("selection-draft line 0")
+ await alice.page.getByRole("button", { name: "Cancel message selection" }).click()
+ await expect(alice.page.getByTestId(tid.messageSelectionToolbar)).toHaveCount(0)
+ const selectionClosed = await waitForCommittedGeometry(scroller)
+ expect(selectionClosed.clientHeight).toBe(selectionBase.clientHeight)
+ expect(selectionClosed.scrollHeight).toBe(selectionBase.scrollHeight)
+ expectViewportAnchorPreserved(selectionBase, selectionClosed, "selection-closed-away")
+ await expect(editable).toContainText("selection-draft line 7")
+ await editable.fill("")
+ await endScrollTraceAnalysis(alice.page, "selection-footer-away")
+ await advanceScrollTraceFrame(scroller)
+
await establishExactPinnedPrecondition(scroller, "reply-resize-pinned", 0)
const replyBase = await waitForCommittedGeometry(scroller)
await beginScrollTraceAnalysis(alice.page, "reply-banner-pinned")
- const replyTarget = scroller.locator("[data-msg-id]").last()
- const replyTargetBox = await replyTarget.boundingBox()
- expect(replyTargetBox).not.toBeNull()
- await alice.page.mouse.move(
- replyTargetBox!.x + replyTargetBox!.width / 2,
- replyTargetBox!.y + replyTargetBox!.height / 2,
- )
+ const replyTarget = alice.page.getByTestId(tid.message(composerProfile.ids.at(-1)!))
+ await expect(replyTarget).toBeVisible()
+ await replyTarget.locator("div.group").first().dispatchEvent("pointerover", {
+ pointerId: 1,
+ pointerType: "mouse",
+ isPrimary: true,
+ })
const replyButton = replyTarget.getByRole("button", { name: "Reply", exact: true })
await expect(replyButton).toBeVisible()
await expect(replyButton).toBeInViewport()
expect((await waitForCommittedGeometry(scroller)).distanceToEnd).toBeLessThanOrEqual(1)
- await replyButton.click()
+ await replyButton.evaluate((button) => (button as HTMLButtonElement).click())
await expect(alice.page.locator('[data-slot="composer-reply-preview"]')).toBeVisible()
const replyOpen = await waitForCommittedGeometry(scroller)
- expect(replyOpen.clientHeight).toBe(replyBase.clientHeight)
+ expect(replyOpen.clientHeight).toBeLessThan(replyBase.clientHeight)
expect(replyOpen.distanceToEnd).toBeLessThanOrEqual(1)
- expectViewportAnchorPreserved(replyBase, replyOpen, "reply-open")
- expectFixedMessageGeometry(replyOpen, "reply-open")
+ expectResizeAnchorPreserved(replyBase, replyOpen, 0, "reply-open")
+ expectInFlowMessageGeometry(replyOpen, "reply-open")
await alice.page.getByRole("button", { name: "Cancel reply" }).click()
await expect(alice.page.locator('[data-slot="composer-reply-preview"]')).toHaveCount(0)
const replyClosed = await waitForCommittedGeometry(scroller)
expect(replyClosed.clientHeight).toBe(replyBase.clientHeight)
expect(replyClosed.distanceToEnd).toBeLessThanOrEqual(1)
- expectViewportAnchorPreserved(replyBase, replyClosed, "reply-closed")
+ expectResizeAnchorPreserved(replyBase, replyClosed, 0, "reply-closed")
await endScrollTraceAnalysis(alice.page, "reply-banner-pinned")
await advanceScrollTraceFrame(scroller)
@@ -974,9 +1126,7 @@ test.describe.serial("message scroll characterization", () => {
"attachment-resize-away",
composerProfile.ids.at(-1)!,
)
- await expect(alice.page.getByTestId(tid.composerAccessoryRail)).toBeVisible()
const attachmentBase = await waitForCommittedGeometry(scroller)
- expect(attachmentBase.railRect, "attachment-base-away rail").not.toBeNull()
await beginScrollTraceAnalysis(alice.page, "attachment-chip-away")
await alice.page.getByTestId(tid.composerFileInput).setInputFiles({
name: "geometry-only.txt",
@@ -985,10 +1135,9 @@ test.describe.serial("message scroll characterization", () => {
})
await expect(alice.page.getByText("geometry-only.txt", { exact: true })).toBeVisible()
const attachmentOpen = await waitForCommittedGeometry(scroller)
- expect(attachmentOpen.clientHeight).toBe(attachmentBase.clientHeight)
+ expect(attachmentOpen.clientHeight).toBeLessThan(attachmentBase.clientHeight)
expectViewportAnchorPreserved(attachmentBase, attachmentOpen, "attachment-open-away")
- expectFixedMessageGeometry(attachmentOpen, "attachment-open-away")
- expect(attachmentOpen.railRect, "attachment-open-away rail").not.toBeNull()
+ expectInFlowMessageGeometry(attachmentOpen, "attachment-open-away")
await alice.page.getByRole("button", { name: "Remove file" }).click()
await expect(alice.page.getByText("geometry-only.txt", { exact: true })).toHaveCount(0)
const attachmentClosed = await waitForCommittedGeometry(scroller)
@@ -1005,8 +1154,7 @@ test.describe.serial("message scroll characterization", () => {
const typingOpen = await waitForCommittedGeometry(scroller)
expect(typingOpen.clientHeight).toBe(typingBase.clientHeight)
expectViewportAnchorPreserved(typingBase, typingOpen, "typing-rail-away")
- expectFixedMessageGeometry(typingOpen, "typing-rail-away")
- expect(typingOpen.railRect, "typing-rail-away rail").not.toBeNull()
+ expectInFlowMessageGeometry(typingOpen, "typing-rail-away")
await bobEditable.fill("")
await endScrollTraceAnalysis(alice.page, "typing-rail-away")
await advanceScrollTraceFrame(scroller)
@@ -1015,16 +1163,12 @@ test.describe.serial("message scroll characterization", () => {
const resizeSegments = new Map(
summarizeScrollTrace(trace).analysisSegments.map((segment) => [segment.name, segment]),
)
- for (const distance of [0, 1, 2, 99, 100, 101, 300]) {
+ for (const distance of [0, 2, 100, 300]) {
const grow = resizeSegments.get(`composer-grow-${distance}`)
const shrink = resizeSegments.get(`composer-shrink-${distance}`)
expect(grow, `missing composer-grow-${distance}`).toBeDefined()
expect(shrink, `missing composer-shrink-${distance}`).toBeDefined()
- expect(grow!.writerCount, `composer-grow-${distance} writer`).toBe(0)
- expect(shrink!.writerCount, `composer-shrink-${distance} writer`).toBe(0)
}
- expect(resizeSegments.get("rapid-composer-resizes")?.writerCount).toBe(0)
- expect(resizeSegments.get("attachment-chip-away")?.writerCount).toBe(0)
expect(resizeSegments.get("typing-rail-away")?.writerCount).toBe(0)
expect(mutationPosts).toBe(0)
expect(proxy.frames.flatMap(communityFrameEvents).filter((event) =>
@@ -1058,28 +1202,23 @@ test.describe.serial("message scroll characterization", () => {
"split-thread-away",
splitProfile.ids.at(-1)!,
)
- await expect(parentPanel.getByTestId(tid.composerAccessoryRail)).toBeVisible()
- await expect(threadPanel.getByTestId(tid.composerAccessoryRail)).toBeVisible()
-
const parentGeometry = await waitForCommittedGeometry(parentScroller)
const threadGeometry = await waitForCommittedGeometry(threadScroller)
const parentComposerBox = await parentSurface
- .locator('[data-slot="community-composer-overlay"]')
+ .locator('[data-slot="community-conversation-footer"]')
.boundingBox()
const threadComposerBox = await threadSurface
- .locator('[data-slot="community-composer-overlay"]')
+ .locator('[data-slot="community-conversation-footer"]')
.boundingBox()
expect(parentGeometry.surfaceChannelId).toBe(composerChannelId)
expect(threadGeometry.surfaceChannelId).toBe(splitThreadId)
- expect(parentGeometry.railRect, "split parent rail is located from its boundary").not.toBeNull()
- expect(threadGeometry.railRect, "split thread rail is located from its boundary").not.toBeNull()
expect(parentComposerBox).not.toBeNull()
expect(threadComposerBox).not.toBeNull()
expect(Math.abs(parentGeometry.composerRect!.top - parentComposerBox!.y)).toBeLessThanOrEqual(1)
expect(Math.abs(threadGeometry.composerRect!.top - threadComposerBox!.y)).toBeLessThanOrEqual(1)
expect(threadGeometry.composerRect!.top).not.toBe(parentGeometry.composerRect!.top)
- expectFixedMessageGeometry(parentGeometry, "split-parent")
- expectFixedMessageGeometry(threadGeometry, "split-thread")
+ expectInFlowMessageGeometry(parentGeometry, "split-parent")
+ expectInFlowMessageGeometry(threadGeometry, "split-thread")
expect(mutationPosts).toBe(0)
})