Page MenuHomePhabricator
Differential D11916

[native] Consume `useThreadInChatList` in `native/ThreadSettings`
ClosedPublic
Actions

Authored by atul on May 6 2024, 2:11 PM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 1, 3:26 AM
Unknown Object (File)
Mon, Mar 31, 8:58 AM
Unknown Object (File)
Sun, Mar 30, 5:43 PM
Unknown Object (File)
Sun, Mar 30, 3:48 PM
Unknown Object (File)
Sun, Mar 30, 1:11 AM
Unknown Object (File)
Sat, Mar 29, 12:33 PM
Unknown Object (File)
Thu, Mar 27, 6:20 AM
Unknown Object (File)
Wed, Mar 19, 2:26 PM
View All 85 Files
Subscribers
None

Details

Reviewers
ashoat
ginsu
tomek
varun
will
Commits
rCOMMd90270ac68f8: [native] Consume `useThreadInChatList` in `native/ThreadSettings`
Summary

Similar to rest of stack, we want to replace usages of threadHasPermission with useThreadHasPermission which we're doing indirectly when we replace threadInChatList with useThreadInChatList.

Depends on D11915

Test Plan

flow + close reading for now

Logged value of isThreadInChatList and ensured it was same before/after change.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

atul created this revision.May 6 2024, 2:11 PM
atul published this revision for review.May 6 2024, 2:16 PM
Harbormaster completed remote builds in B28720: Diff 39874.May 6 2024, 2:29 PM
tomek accepted this revision.May 7 2024, 1:53 AM

flow + close reading for now

Sounds risky for a change that changes the flow.

native/chat/settings/thread-settings.react.js
1166 ↗(On Diff #39874)

I find these names a bit confusing - they don't indicate that they are boolean flags. This might be expensive, but I think it would be better to put is somewhere inside them.

This revision is now accepted and ready to land.May 7 2024, 1:53 AM
atul added a child revision: D11924: [lib] Introduce `useThreadsWithPermission` to filter `ThreadInfo`s.May 7 2024, 9:21 AM
atul edited the test plan for this revision. (Show Details)May 14 2024, 1:15 PM
atul updated this revision to Diff 40182.May 14 2024, 1:17 PM

address feedback (useThreadInChatList -> useIsThreadInChatList)

This revision was landed with ongoing or failed builds.May 14 2024, 1:26 PM
Closed by commit rCOMMd90270ac68f8: [native] Consume `useThreadInChatList` in `native/ThreadSettings` (authored by atul). · Explain Why
This revision was automatically updated to reflect the committed changes.
atul added a commit: rCOMMd90270ac68f8: [native] Consume `useThreadInChatList` in `native/ThreadSettings`.
Harbormaster completed remote builds in B28912: Diff 40182.May 14 2024, 1:35 PM

Revision Contents
Changeset List

PathSize
lib/
shared/
4 lines
native/
chat/
settings/
7 lines
web/
chat/
4 lines

Diff 40183

View Options

lib/shared/thread-utils.js

// @flow // @flow
import * as React from 'react'; import * as React from 'react';
import { useGetMessageAuthor } from './message-author.js'; import { useGetMessageAuthor } from './message-author.js';
import { messageInfoSelector } from '../selectors/chat-selectors.js'; import { messageInfoSelector } from '../selectors/chat-selectors.js';
import { import {
getOldestNonLocalMessageID, getOldestNonLocalMessageID,
useFetchMessages, useFetchMessages,
} from '../shared/message-utils.js'; } from '../shared/message-utils.js';
import { messageSpecs } from '../shared/messages/message-specs.js'; import { messageSpecs } from '../shared/messages/message-specs.js';
import type { MessageInfo } from '../types/message-types.js'; import {
type MessageInfo,
defaultNumberPerThread,
} from '../types/message-types.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js'; import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import { useSelector } from '../utils/redux-utils.js'; import { useSelector } from '../utils/redux-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
function useOldestMessageServerID(threadID: string): ?string { function useOldestMessageServerID(threadID: string): ?string {
return useSelector(state => return useSelector(state =>
getOldestNonLocalMessageID(threadID, state.messageStore), getOldestNonLocalMessageID(threadID, state.messageStore),
); );
} }
type MessageInfoForPreview = { type MessageInfoForPreview = {
+messageInfoForPreview: ?MessageInfo, +messageInfoForPreview: ?MessageInfo,
// If showInMessagePreview rejects all of the messages in the local store, // If showInMessagePreview rejects all of the messages in the local store,
// then we'll ignore it and return the most recent message (if there is one) // then we'll ignore it and return the most recent message (if there is one)
// as messageInfoForPreview. In this case, we'll also set // as messageInfoForPreview. In this case, we'll also set
// shouldFetchOlderMessages to tell the caller to fetch more messages. // numOlderMessagesToFetch to tell the caller how many more messages to fetch.
+shouldFetchOlderMessages: boolean, +numOlderMessagesToFetch: number,
}; };
const emptyMessageInfoForPreview = { const emptyMessageInfoForPreview = {
messageInfoForPreview: undefined, messageInfoForPreview: undefined,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
function useGetMessageInfoForPreview(): ( function useGetMessageInfoForPreview(): (
threadInfo: ThreadInfo, threadInfo: ThreadInfo,
) => Promise<MessageInfoForPreview> { ) => Promise<MessageInfoForPreview> {
const messageInfos = useSelector(messageInfoSelector); const messageInfos = useSelector(messageInfoSelector);
const messageStore = useSelector(state => state.messageStore); const messageStore = useSelector(state => state.messageStore);
const viewerID = useSelector(state => state.currentUserInfo?.id); const viewerID = useSelector(state => state.currentUserInfo?.id);
Show All 20 Lines async threadInfo => {
} }
if (!mostRecentMessageInfo) { if (!mostRecentMessageInfo) {
mostRecentMessageInfo = messageInfo; mostRecentMessageInfo = messageInfo;
} }
const { showInMessagePreview } = messageSpecs[messageInfo.type]; const { showInMessagePreview } = messageSpecs[messageInfo.type];
if (!showInMessagePreview) { if (!showInMessagePreview) {
return { return {
messageInfoForPreview: messageInfo, messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
} }
let shouldShow = showInMessagePreview( let shouldShow = showInMessagePreview(
messageInfo, messageInfo,
showInMessagePreviewParams, showInMessagePreviewParams,
); );
if (shouldShow instanceof Promise) { if (shouldShow instanceof Promise) {
shouldShow = await shouldShow; shouldShow = await shouldShow;
} }
if (shouldShow) { if (shouldShow) {
return { return {
messageInfoForPreview: messageInfo, messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
} }
} }
const numOlderMessagesToFetch = Math.max(
defaultNumberPerThread - thread.messageIDs.length,
0,
);
// If we get here, that means showInMessagePreview rejected all of the // If we get here, that means showInMessagePreview rejected all of the
// messages in the local store // messages in the local store
return { return {
messageInfoForPreview: mostRecentMessageInfo, messageInfoForPreview: mostRecentMessageInfo,
shouldFetchOlderMessages: true, numOlderMessagesToFetch,
}; };
}, },
[messageInfos, messageStore, viewerID, getMessageAuthor], [messageInfos, messageStore, viewerID, getMessageAuthor],
); );
} }
function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo { function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo {
const [messageInfoForPreview, setMessageInfoForPreview] = const [messageInfoForPreview, setMessageInfoForPreview] =
React.useState<?MessageInfoForPreview>(); React.useState<?MessageInfoForPreview>();
const getMessageInfoForPreview = useGetMessageInfoForPreview(); const getMessageInfoForPreview = useGetMessageInfoForPreview();
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const newMessageInfoForPreview = const newMessageInfoForPreview =
await getMessageInfoForPreview(threadInfo); await getMessageInfoForPreview(threadInfo);
setMessageInfoForPreview(newMessageInfoForPreview); setMessageInfoForPreview(newMessageInfoForPreview);
})(); })();
}, [threadInfo, getMessageInfoForPreview]); }, [threadInfo, getMessageInfoForPreview]);
const shouldFetchOlderMessages = const numOlderMessagesToFetch =
!!messageInfoForPreview?.shouldFetchOlderMessages; messageInfoForPreview?.numOlderMessagesToFetch ?? 0;
const [canFetchOlderMessages, setCanFetchOlderMessages] = const [canFetchOlderMessages, setCanFetchOlderMessages] =
React.useState(true); React.useState(true);
const fetchMessages = useFetchMessages(threadInfo); const fetchMessages = useFetchMessages(threadInfo);
React.useEffect(() => { React.useEffect(() => {
if (!canFetchOlderMessages || !shouldFetchOlderMessages) { if (!canFetchOlderMessages || numOlderMessagesToFetch === 0) {
return; return;
} }
setCanFetchOlderMessages(false); setCanFetchOlderMessages(false);
void (async () => { void (async () => {
await fetchMessages(); await fetchMessages({ numMessagesToFetch: numOlderMessagesToFetch });
await sleep(3000); await sleep(3000);
setCanFetchOlderMessages(true); setCanFetchOlderMessages(true);
})(); })();
}, [canFetchOlderMessages, shouldFetchOlderMessages, fetchMessages]); }, [canFetchOlderMessages, numOlderMessagesToFetch, fetchMessages]);
return messageInfoForPreview?.messageInfoForPreview; return messageInfoForPreview?.messageInfoForPreview;
} }
export { useOldestMessageServerID, useMessageInfoForPreview }; export { useOldestMessageServerID, useMessageInfoForPreview };
View Options

native/chat/settings/thread-settings.react.js

// @flow // @flow
import * as React from 'react'; import * as React from 'react';
import { useGetMessageAuthor } from './message-author.js'; import { useGetMessageAuthor } from './message-author.js';
import { messageInfoSelector } from '../selectors/chat-selectors.js'; import { messageInfoSelector } from '../selectors/chat-selectors.js';
import { import {
getOldestNonLocalMessageID, getOldestNonLocalMessageID,
useFetchMessages, useFetchMessages,
} from '../shared/message-utils.js'; } from '../shared/message-utils.js';
import { messageSpecs } from '../shared/messages/message-specs.js'; import { messageSpecs } from '../shared/messages/message-specs.js';
import type { MessageInfo } from '../types/message-types.js'; import {
type MessageInfo,
defaultNumberPerThread,
} from '../types/message-types.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js'; import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import { useSelector } from '../utils/redux-utils.js'; import { useSelector } from '../utils/redux-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
function useOldestMessageServerID(threadID: string): ?string { function useOldestMessageServerID(threadID: string): ?string {
return useSelector(state => return useSelector(state =>
getOldestNonLocalMessageID(threadID, state.messageStore), getOldestNonLocalMessageID(threadID, state.messageStore),
); );
} }
type MessageInfoForPreview = { type MessageInfoForPreview = {
+messageInfoForPreview: ?MessageInfo, +messageInfoForPreview: ?MessageInfo,
// If showInMessagePreview rejects all of the messages in the local store, // If showInMessagePreview rejects all of the messages in the local store,
// then we'll ignore it and return the most recent message (if there is one) // then we'll ignore it and return the most recent message (if there is one)
// as messageInfoForPreview. In this case, we'll also set // as messageInfoForPreview. In this case, we'll also set
// shouldFetchOlderMessages to tell the caller to fetch more messages. // numOlderMessagesToFetch to tell the caller how many more messages to fetch.
+shouldFetchOlderMessages: boolean, +numOlderMessagesToFetch: number,
}; };
const emptyMessageInfoForPreview = { const emptyMessageInfoForPreview = {
messageInfoForPreview: undefined, messageInfoForPreview: undefined,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
function useGetMessageInfoForPreview(): ( function useGetMessageInfoForPreview(): (
threadInfo: ThreadInfo, threadInfo: ThreadInfo,
) => Promise<MessageInfoForPreview> { ) => Promise<MessageInfoForPreview> {
const messageInfos = useSelector(messageInfoSelector); const messageInfos = useSelector(messageInfoSelector);
const messageStore = useSelector(state => state.messageStore); const messageStore = useSelector(state => state.messageStore);
const viewerID = useSelector(state => state.currentUserInfo?.id); const viewerID = useSelector(state => state.currentUserInfo?.id);
Show All 20 Lines async threadInfo => {
} }
if (!mostRecentMessageInfo) { if (!mostRecentMessageInfo) {
mostRecentMessageInfo = messageInfo; mostRecentMessageInfo = messageInfo;
} }
const { showInMessagePreview } = messageSpecs[messageInfo.type]; const { showInMessagePreview } = messageSpecs[messageInfo.type];
if (!showInMessagePreview) { if (!showInMessagePreview) {
return { return {
messageInfoForPreview: messageInfo, messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
} }
let shouldShow = showInMessagePreview( let shouldShow = showInMessagePreview(
messageInfo, messageInfo,
showInMessagePreviewParams, showInMessagePreviewParams,
); );
if (shouldShow instanceof Promise) { if (shouldShow instanceof Promise) {
shouldShow = await shouldShow; shouldShow = await shouldShow;
} }
if (shouldShow) { if (shouldShow) {
return { return {
messageInfoForPreview: messageInfo, messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
} }
} }
const numOlderMessagesToFetch = Math.max(
defaultNumberPerThread - thread.messageIDs.length,
0,
);
// If we get here, that means showInMessagePreview rejected all of the // If we get here, that means showInMessagePreview rejected all of the
// messages in the local store // messages in the local store
return { return {
messageInfoForPreview: mostRecentMessageInfo, messageInfoForPreview: mostRecentMessageInfo,
shouldFetchOlderMessages: true, numOlderMessagesToFetch,
}; };
}, },
[messageInfos, messageStore, viewerID, getMessageAuthor], [messageInfos, messageStore, viewerID, getMessageAuthor],
); );
} }
function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo { function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo {
const [messageInfoForPreview, setMessageInfoForPreview] = const [messageInfoForPreview, setMessageInfoForPreview] =
React.useState<?MessageInfoForPreview>(); React.useState<?MessageInfoForPreview>();
const getMessageInfoForPreview = useGetMessageInfoForPreview(); const getMessageInfoForPreview = useGetMessageInfoForPreview();
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const newMessageInfoForPreview = const newMessageInfoForPreview =
await getMessageInfoForPreview(threadInfo); await getMessageInfoForPreview(threadInfo);
setMessageInfoForPreview(newMessageInfoForPreview); setMessageInfoForPreview(newMessageInfoForPreview);
})(); })();
}, [threadInfo, getMessageInfoForPreview]); }, [threadInfo, getMessageInfoForPreview]);
const shouldFetchOlderMessages = const numOlderMessagesToFetch =
!!messageInfoForPreview?.shouldFetchOlderMessages; messageInfoForPreview?.numOlderMessagesToFetch ?? 0;
const [canFetchOlderMessages, setCanFetchOlderMessages] = const [canFetchOlderMessages, setCanFetchOlderMessages] =
React.useState(true); React.useState(true);
const fetchMessages = useFetchMessages(threadInfo); const fetchMessages = useFetchMessages(threadInfo);
React.useEffect(() => { React.useEffect(() => {
if (!canFetchOlderMessages || !shouldFetchOlderMessages) { if (!canFetchOlderMessages || numOlderMessagesToFetch === 0) {
return; return;
} }
setCanFetchOlderMessages(false); setCanFetchOlderMessages(false);
void (async () => { void (async () => {
await fetchMessages(); await fetchMessages({ numMessagesToFetch: numOlderMessagesToFetch });
await sleep(3000); await sleep(3000);
setCanFetchOlderMessages(true); setCanFetchOlderMessages(true);
})(); })();
}, [canFetchOlderMessages, shouldFetchOlderMessages, fetchMessages]); }, [canFetchOlderMessages, numOlderMessagesToFetch, fetchMessages]);
return messageInfoForPreview?.messageInfoForPreview; return messageInfoForPreview?.messageInfoForPreview;
} }
export { useOldestMessageServerID, useMessageInfoForPreview }; export { useOldestMessageServerID, useMessageInfoForPreview };
View Options

web/chat/thread-list-provider.js

// @flow // @flow
import * as React from 'react'; import * as React from 'react';
import { useGetMessageAuthor } from './message-author.js'; import { useGetMessageAuthor } from './message-author.js';
import { messageInfoSelector } from '../selectors/chat-selectors.js'; import { messageInfoSelector } from '../selectors/chat-selectors.js';
import { import {
getOldestNonLocalMessageID, getOldestNonLocalMessageID,
useFetchMessages, useFetchMessages,
} from '../shared/message-utils.js'; } from '../shared/message-utils.js';
import { messageSpecs } from '../shared/messages/message-specs.js'; import { messageSpecs } from '../shared/messages/message-specs.js';
import type { MessageInfo } from '../types/message-types.js'; import {
type MessageInfo,
defaultNumberPerThread,
} from '../types/message-types.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js'; import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
import { useSelector } from '../utils/redux-utils.js'; import { useSelector } from '../utils/redux-utils.js';
import sleep from '../utils/sleep.js'; import sleep from '../utils/sleep.js';
function useOldestMessageServerID(threadID: string): ?string { function useOldestMessageServerID(threadID: string): ?string {
return useSelector(state => return useSelector(state =>
getOldestNonLocalMessageID(threadID, state.messageStore), getOldestNonLocalMessageID(threadID, state.messageStore),
); );
} }
type MessageInfoForPreview = { type MessageInfoForPreview = {
+messageInfoForPreview: ?MessageInfo, +messageInfoForPreview: ?MessageInfo,
// If showInMessagePreview rejects all of the messages in the local store, // If showInMessagePreview rejects all of the messages in the local store,
// then we'll ignore it and return the most recent message (if there is one) // then we'll ignore it and return the most recent message (if there is one)
// as messageInfoForPreview. In this case, we'll also set // as messageInfoForPreview. In this case, we'll also set
// shouldFetchOlderMessages to tell the caller to fetch more messages. // numOlderMessagesToFetch to tell the caller how many more messages to fetch.
+shouldFetchOlderMessages: boolean, +numOlderMessagesToFetch: number,
}; };
const emptyMessageInfoForPreview = { const emptyMessageInfoForPreview = {
messageInfoForPreview: undefined, messageInfoForPreview: undefined,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
function useGetMessageInfoForPreview(): ( function useGetMessageInfoForPreview(): (
threadInfo: ThreadInfo, threadInfo: ThreadInfo,
) => Promise<MessageInfoForPreview> { ) => Promise<MessageInfoForPreview> {
const messageInfos = useSelector(messageInfoSelector); const messageInfos = useSelector(messageInfoSelector);
const messageStore = useSelector(state => state.messageStore); const messageStore = useSelector(state => state.messageStore);
const viewerID = useSelector(state => state.currentUserInfo?.id); const viewerID = useSelector(state => state.currentUserInfo?.id);
Show All 20 Lines async threadInfo => {
} }
if (!mostRecentMessageInfo) { if (!mostRecentMessageInfo) {
mostRecentMessageInfo = messageInfo; mostRecentMessageInfo = messageInfo;
} }
const { showInMessagePreview } = messageSpecs[messageInfo.type]; const { showInMessagePreview } = messageSpecs[messageInfo.type];
if (!showInMessagePreview) { if (!showInMessagePreview) {
return { return {
messageInfoForPreview: messageInfo, messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
} }
let shouldShow = showInMessagePreview( let shouldShow = showInMessagePreview(
messageInfo, messageInfo,
showInMessagePreviewParams, showInMessagePreviewParams,
); );
if (shouldShow instanceof Promise) { if (shouldShow instanceof Promise) {
shouldShow = await shouldShow; shouldShow = await shouldShow;
} }
if (shouldShow) { if (shouldShow) {
return { return {
messageInfoForPreview: messageInfo, messageInfoForPreview: messageInfo,
shouldFetchOlderMessages: false, numOlderMessagesToFetch: 0,
}; };
} }
} }
const numOlderMessagesToFetch = Math.max(
defaultNumberPerThread - thread.messageIDs.length,
0,
);
// If we get here, that means showInMessagePreview rejected all of the // If we get here, that means showInMessagePreview rejected all of the
// messages in the local store // messages in the local store
return { return {
messageInfoForPreview: mostRecentMessageInfo, messageInfoForPreview: mostRecentMessageInfo,
shouldFetchOlderMessages: true, numOlderMessagesToFetch,
}; };
}, },
[messageInfos, messageStore, viewerID, getMessageAuthor], [messageInfos, messageStore, viewerID, getMessageAuthor],
); );
} }
function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo { function useMessageInfoForPreview(threadInfo: ThreadInfo): ?MessageInfo {
const [messageInfoForPreview, setMessageInfoForPreview] = const [messageInfoForPreview, setMessageInfoForPreview] =
React.useState<?MessageInfoForPreview>(); React.useState<?MessageInfoForPreview>();
const getMessageInfoForPreview = useGetMessageInfoForPreview(); const getMessageInfoForPreview = useGetMessageInfoForPreview();
React.useEffect(() => { React.useEffect(() => {
void (async () => { void (async () => {
const newMessageInfoForPreview = const newMessageInfoForPreview =
await getMessageInfoForPreview(threadInfo); await getMessageInfoForPreview(threadInfo);
setMessageInfoForPreview(newMessageInfoForPreview); setMessageInfoForPreview(newMessageInfoForPreview);
})(); })();
}, [threadInfo, getMessageInfoForPreview]); }, [threadInfo, getMessageInfoForPreview]);
const shouldFetchOlderMessages = const numOlderMessagesToFetch =
!!messageInfoForPreview?.shouldFetchOlderMessages; messageInfoForPreview?.numOlderMessagesToFetch ?? 0;
const [canFetchOlderMessages, setCanFetchOlderMessages] = const [canFetchOlderMessages, setCanFetchOlderMessages] =
React.useState(true); React.useState(true);
const fetchMessages = useFetchMessages(threadInfo); const fetchMessages = useFetchMessages(threadInfo);
React.useEffect(() => { React.useEffect(() => {
if (!canFetchOlderMessages || !shouldFetchOlderMessages) { if (!canFetchOlderMessages || numOlderMessagesToFetch === 0) {
return; return;
} }
setCanFetchOlderMessages(false); setCanFetchOlderMessages(false);
void (async () => { void (async () => {
await fetchMessages(); await fetchMessages({ numMessagesToFetch: numOlderMessagesToFetch });
await sleep(3000); await sleep(3000);
setCanFetchOlderMessages(true); setCanFetchOlderMessages(true);
})(); })();
}, [canFetchOlderMessages, shouldFetchOlderMessages, fetchMessages]); }, [canFetchOlderMessages, numOlderMessagesToFetch, fetchMessages]);
return messageInfoForPreview?.messageInfoForPreview; return messageInfoForPreview?.messageInfoForPreview;
} }
export { useOldestMessageServerID, useMessageInfoForPreview }; export { useOldestMessageServerID, useMessageInfoForPreview };