Function useExistingThreadInfoFinder

lib/shared/thread-utils.js:1177–1253

(
  baseThreadInfo: ?ThreadInfo,
)

) => ?ThreadInfo;

function useExistingThreadInfoFinder(
  baseThreadInfo: ?ThreadInfo,
): ExistingThreadInfoFinder {
  const threadInfos = useSelector(threadInfoSelector);
  const loggedInUserInfo = useLoggedInUserInfo();

  const pendingToRealizedThreadIDs = useSelector(state =>
    pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
  );
  return React.useCallback(
    (params: ExistingThreadInfoFinderParams): ?ThreadInfo => {
      if (!baseThreadInfo) {
        return null;
      }

      const realizedThreadInfo = threadInfos[baseThreadInfo.id];
      if (realizedThreadInfo) {
        return realizedThreadInfo;
      }

      if (!loggedInUserInfo || !threadIsPending(baseThreadInfo.id)) {
        return baseThreadInfo;
      }
      const viewerID = loggedInUserInfo?.id;

      invariant(
        threadTypeCanBePending(baseThreadInfo.type),
        `ThreadInfo has pending ID ${baseThreadInfo.id}, but type that ` +
          `should not be pending ${baseThreadInfo.type}`,
      );

      const { sourceMessageID } = baseThreadInfo;

      let pendingThreadID;
      if (params.searching) {
        const { userInfoInputArray, matchProtocol, pendingThreadProtocol } =
          params;
        const protocol = getProtocolByName(pendingThreadProtocol);
        invariant(protocol, `unsupported protocol ${pendingThreadProtocol}`);
        pendingThreadID = getPendingThreadID(
          protocol.pendingThreadType(userInfoInputArray.length),
          [...userInfoInputArray.map(user => user.id), viewerID],
          sourceMessageID,
          matchProtocol,
        );
      } else {
        pendingThreadID = getPendingThreadID(
          baseThreadInfo.type,
          baseThreadInfo.members.map(member => member.id),
          sourceMessageID,
          threadSpecs[baseThreadInfo.type].protocol().protocolName,
        );
      }
      const realizedThreadID = pendingToRealizedThreadIDs.get(pendingThreadID);
      if (realizedThreadID && threadInfos[realizedThreadID]) {
        return threadInfos[realizedThreadID];
      }