[lib] Rename `sansFarcaster` variable names and types to `Traditional*`
ClosedPublic
Actions

Authored by atul on Apr 9 2024, 6:40 PM.

Details

Reviewers

ginsu
tomek
will
varun

Commits

rCOMM5f8a4e609540: [lib] Rename `sansFarcaster` variable names and types to `Traditional*`

Summary

Including farcaster in all of these types and variables when it's often completely irrelevant doesn't make sense. Calling them Legacy* doesn't quite make sense either since they're def not being phased out, so settled on Traditional* to keep consistent with D11602

Depends on D11602

Test Plan

NA, simple rename

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

atul created this revision.Apr 9 2024, 6:40 PM

Herald added a subscriber: ashoat. · View Herald TranscriptApr 9 2024, 6:40 PM

Harbormaster completed remote builds in B28103: Diff 38959.Apr 9 2024, 6:59 PM

atul requested review of this revision.Apr 9 2024, 6:59 PM

atul added a child revision: D11604: [keyserver] Update `updateRelationshipInputValidator` to accept both traditional/farcaster requests.Apr 9 2024, 7:50 PM

atul added a child revision: D11605: [lib] Re-introduce `RelationshipRequest` and replace `TraditionalRelationshipRequest` where simple.Apr 9 2024, 8:06 PM

ginsu accepted this revision.Apr 9 2024, 10:06 PM

This revision is now accepted and ready to land.Apr 9 2024, 10:06 PM

land

This revision was landed with ongoing or failed builds.Apr 10 2024, 11:51 AM

Closed by commit rCOMM5f8a4e609540: [lib] Rename `sansFarcaster` variable names and types to `Traditional*` (authored by atul). · Explain Why

This revision was automatically updated to reflect the committed changes.

atul added a commit: rCOMM5f8a4e609540: [lib] Rename `sansFarcaster` variable names and types to `Traditional*`.

Harbormaster completed remote builds in B28133: Diff 38997.Apr 10 2024, 11:55 AM

Revision Contents
Changeset List

Path

Size

lib/

types/

relationship-types.js

8 lines

Diff 38998

View Options

lib/types/relationship-types.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 };

[lib] Rename `sansFarcaster` variable names and types to `Traditional*`ClosedPublicActions