Page MenuHomePhabricator
Differential D10133

[lib] `ResolvedThreadInfo` -> `LegacyResolvedThreadInfo`
ClosedPublic
Actions

Authored by atul on Dec 1 2023, 5:49 AM.
Tags
None
Referenced Files
Unknown Object (File)
Feb 27 2025, 7:23 PM
Unknown Object (File)
Feb 27 2025, 7:15 PM
Unknown Object (File)
Feb 27 2025, 7:15 PM
Unknown Object (File)
Feb 26 2025, 8:19 AM
Unknown Object (File)
Feb 21 2025, 5:50 AM
Unknown Object (File)
Feb 8 2025, 3:28 PM
Unknown Object (File)
Jan 29 2025, 11:54 AM
Unknown Object (File)
Jan 28 2025, 4:01 PM
View All 74 Files
Subscribers
None

Details

Reviewers
ashoat
ginsu
tomek
rohan
Commits
rCOMM774b77618c90: [lib] `ResolvedThreadInfo` -> `LegacyResolvedThreadInfo`
Summary

Simple rename similar to D10077 and D10095, but for ResolvedThreadInfo

Depends on D10128

Test Plan

CI/flow/etc

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

Diff 34153

View Options

lib/components/chat-mention-provider.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

lib/shared/markdown.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

lib/shared/mention-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

lib/shared/mention-utils.test.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

lib/types/filter-types.js

Loading...
View Options

lib/types/thread-types.js

Loading...
View Options

lib/utils/drawer-utils.react.js

Loading...
View Options

lib/utils/entity-helpers.js

Loading...
View Options

native/avatars/thread-avatar.react.js

Loading...
View Options

native/calendar/entry.react.js

Loading...
View Options

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

Loading...
View Options

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

Loading...
View Options

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

Loading...
View Options

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

Loading...
View Options

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

Loading...
View Options

native/components/thread-list-thread.react.js

Loading...
View Options

native/markdown/markdown-chat-mention.react.js

Loading...
View Options

web/calendar/entry.react.js

Loading...
View Options

web/markdown/markdown-chat-mention.react.js

Loading...
View Options

web/modals/history/history-entry.react.js

Loading...