discord-decomp/modules/safety_flows/usePendingParentRequests.tsx

// Metro module 16719 (f16720).
import { useMemo, useState, useCallback } from "react";
import FamilyCenterStore from "../parent_tools/FamilyCenterStore";
import UserStore from "../../stores/UserStore";
import { UserLinkStatus } from "../parent_tools/FamilyCenterConstants";
import { useStateFromStores } from "../../_bundle/Module589";
import { useHasMaxConnections } from "../parent_tools/hooks/useUserLinks";
import { useFamilyCenterActions } from "../parent_tools/hooks/useFamilyCenterActions";
export function useDerivedPendingRequests(a0, a1) {
  let stateFromStores2;
  const stateFromStores = useStateFromStores([FamilyCenterStore], () => FamilyCenterStore.getLinkedUsers());
  stateFromStores2 = useStateFromStores([UserStore], () => UserStore.getCurrentUser()?.id);
  return useMemo(() => {
    if (!a1) {
      return a0;
    }
    const map = new Map(a0.map((item) => [item.parent_id, item]));
    const r32 = [];
    for (const item of Object.values(stateFromStores)) {
      if (item != null && item.link_status === UserLinkStatus.PENDING && item.requestor_id !== stateFromStores2) {
        const user = UserStore.getUser(item.user_id);
        const r57 = map.get(item.user_id);
        let parent_username = user?.username;
        if (parent_username == null) {
          parent_username = r57?.parent_username;
        }
        if (parent_username == null) {
          parent_username = item.user_id;
        }
        let parent_avatar = user?.avatar;
        if (parent_avatar == null) {
          parent_avatar = r57?.parent_avatar;
        }
        if (parent_avatar == null) {
          parent_avatar = null;
        }
        r32.push({
          parent_id: item.user_id,
          parent_username,
          parent_avatar,
          created_at: item.created_at
        });
      }
    }
    return r32;
  }, [a1, stateFromStores, stateFromStores2, a0]);
}
export function usePendingRequestListController({ pendingRequests, linkedUsersProcessed, onActionError }) {
  let acceptLinkRequest, declineLinkRequest, isDeclineLoading, state, setState2, callback;
  acceptLinkRequest = void 0;
  declineLinkRequest = void 0;
  isDeclineLoading = void 0;
  state = void 0;
  setState2 = void 0;
  callback = void 0;
  const hasMaxConnections = useHasMaxConnections();
  const [actioningUserId, setState] = useState(null);
  const familyCenterActions = useFamilyCenterActions({
    onSuccess: () => setState(null),
    onError: () => {
      setState(null);
      onActionError();
    }
  });
  acceptLinkRequest = familyCenterActions.acceptLinkRequest;
  declineLinkRequest = familyCenterActions.declineLinkRequest;
  const { isAcceptLoading, isDeclineLoading: isDeclineLoading2 } = familyCenterActions;
  isDeclineLoading = isAcceptLoading || isDeclineLoading2;
  [state, setState2] = useState(() => new Set());
  callback = useCallback((c28506_0) => {
    setState2((prevState2) => {
      const has = prevState2.has;
      if (has.call(prevState2, c28506_0)) {
        return prevState2;
      }
      const set = new Set(prevState2);
      set.add(c28506_0);
      return set;
    });
  }, []);
  const callback2 = useCallback((a0) => {
    if (!isDeclineLoading) {
      callback(a0);
      setState(a0);
      acceptLinkRequest(a0);
    }
  }, [isDeclineLoading, callback, acceptLinkRequest]);
  const callback3 = useCallback((a0) => {
    if (!isDeclineLoading) {
      callback(a0);
      setState(a0);
      declineLinkRequest(a0);
    }
  }, [isDeclineLoading, callback, declineLinkRequest]);
  const [seenRequests, setState3] = useState(pendingRequests);
  const [state2, setState4] = useState(pendingRequests);
  const [state3, setState5] = useState(linkedUsersProcessed);
  if (linkedUsersProcessed && !state3) {
    setState5(true);
    setState4(pendingRequests);
    setState3((prevState3) => {
      const map = new Map();
      for (const item of prevState3) {
        if (state.has(item.parent_id)) {
          map.set(item.parent_id, item);
        }
      }
      for (const pendingRequest of pendingRequests) {
        map.set(pendingRequest.parent_id, pendingRequest);
      }
      return Array.from(map.values());
    });
  } else if (pendingRequests !== state2) {
    setState4(pendingRequests);
    setState3((prevState3) => {
      const map = new Map(prevState3.map((item) => [item.parent_id, item]));
      for (const pendingRequest of pendingRequests) {
        map.set(pendingRequest.parent_id, pendingRequest);
      }
      return Array.from(map.values());
    });
  }
  return {
    seenRequests,
    hasMaxConnections,
    actioningUserId,
    isAcceptLoading,
    isDeclineLoading: isDeclineLoading2,
    actionsDisabled: isDeclineLoading,
    handleAccept: callback2,
    handleDecline: callback3
  };
}
export function usePendingRequestResolution(c23390_0) {
  const stateFromStores3 = useStateFromStores([FamilyCenterStore], () => FamilyCenterStore.getLinkedUsers()[c23390_0]?.link_status);
  const [state, setState] = useState(() => stateFromStores3 !== UserLinkStatus.ACTIVE ? stateFromStores3 != null ? stateFromStores3 === UserLinkStatus.PENDING ? null : "declined" : null : "connected");
  const [state2, setState2] = useState(stateFromStores3);
  if (stateFromStores3 !== state2) {
    setState2(stateFromStores3);
    if (stateFromStores3 === UserLinkStatus.ACTIVE) {
      setState("connected");
    } else if (stateFromStores3 === UserLinkStatus.PENDING) {
      setState(null);
    } else if (stateFromStores3 != null || state2 != null && state2 !== UserLinkStatus.ACTIVE) {
      setState("declined");
    }
  }
  let isConnected = state === "connected";
  const isDeclined = state === "declined";
  const r46 = {
    isConnected,
    isDeclined,
    isResolved: null
  };
  if (!isConnected) {
    isConnected = isDeclined;
  }
  r46.isResolved = isConnected;
  return r46;
}