[lib][native] simplify and rename identity password registration hook
ClosedPublic
Actions

Authored by varun on Feb 14 2024, 11:17 AM.

Details

Reviewers

tomek
ashoat
inka

Commits

rCOMM888001b3f46f: [lib][native] simplify and rename identity password registration hook

Summary

renaming the hook before introducing the wallet counterpart. also simplified the logic based on feedback @tomek gave me on D10961

Depends on D11082

Test Plan

confirmed that password registration with identity service still works

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

varun created this revision.Feb 14 2024, 11:17 AM

Harbormaster completed remote builds in B26841: Diff 37104.Feb 14 2024, 11:33 AM

varun requested review of this revision.Feb 14 2024, 11:33 AM

varun added a child revision: D11084: [lib] useIdentityWalletRegister hook.Feb 14 2024, 12:11 PM

ashoat accepted this revision.Feb 14 2024, 12:48 PM

This revision is now accepted and ready to land.Feb 14 2024, 12:48 PM

Closed by commit rCOMM888001b3f46f: [lib][native] simplify and rename identity password registration hook (authored by varun). · Explain WhyFeb 16 2024, 7:20 AM

This revision was automatically updated to reflect the committed changes.

varun added a commit: rCOMM888001b3f46f: [lib][native] simplify and rename identity password registration hook.

Revision Contents
Changeset List

Path

Size

lib/

actions/

user-actions.js

21 lines

native/

account/

registration/

registration-server-call.js

8 lines

Diff 37312

View Options

lib/actions/user-actions.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 };