yeet

modules/premium/referral_program/hooks/native/useReferralProgramCoachmark.tsx

@@ -0,0 +1,60 @@
+// Metro module 15618 (f15619).
+import { useMemo } from "react";
+import { View } from "react-native";
+import { UserSettingsSections } from "../../../../../Constants";
+import { ContentDismissActionType } from "../../../../dismissible_content/DismissibleContentConstants";
+import { createStyles } from "../../../../../design/components/Styles/native/createStyles";
+import FastImage from "../../../../../components_native/common/FastImage";
+import Module15619 from "../../../../../_bundle/Module15619";
+import { useIsDismissibleContentDismissed_UNSAFE } from "../../../../dismissible_content/DismissibleContentUnsafeUtils";
+import { DismissibleContent } from "../../../../../_bundle/Module1358";
+import { useIsEligibleSenderForReferralProgram } from "../useIsEligibleSenderForReferralProgram";
+import { useSelectedDismissibleContent } from "../../../../dismissible_content/hooks/useSelectedDismissibleContent";
+import { intl, t } from "../../../../../intl/index.native";
+import { isYouNavFloating } from "../../../../main_tabs_v2/native/tabs/you/YouNavFloatingExperiment";
+import Module712 from "../../../../../_bundle/Module712";
+import { openUserSettings } from "../../../../user_settings/core/native/openUserSettings";
+let useStyles;
+const ReferralProgramCoachmarkImg = function ReferralProgramCoachmarkImg() {
+  const styles = useStyles();
+  return <View style={styles.coachmarkImageContainer}>
+    <FastImage source={Module15619} style={styles.coachmarkImage} />
+  </View>;
+};
+useStyles = createStyles({
+  coachmarkImageContainer: {
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  coachmarkImage: {
+    width: 200,
+    height: 112
+  }
+});
+export function useReferralProgramCoachmark({ disabled }) {
+  const [r31, r32] = useSelectedDismissibleContent(useIsEligibleSenderForReferralProgram(useIsDismissibleContentDismissed_UNSAFE(DismissibleContent.REFERRAL_TRIAL_MOBILE_SENDER_COACHMARK) || disabled) && !disabled ? [DismissibleContent.REFERRAL_TRIAL_MOBILE_SENDER_COACHMARK] : []);
+  let c22250_0 = r32;
+  const visible = r31 === DismissibleContent.REFERRAL_TRIAL_MOBILE_SENDER_COACHMARK;
+  const memo = useMemo(() => ({
+    title: intl.string(t.USo4s7),
+    description: intl.string(t.zmcRl4),
+    position: isYouNavFloating() ? "top" : "bottom",
+    offsetY: isYouNavFloating() ? Module712.space.PX_12 : void 0,
+    visible,
+    onDismiss: () => {
+      c22250_0(ContentDismissActionType.USER_DISMISS);
+    },
+    buttonVariant: "experimental_premium-primary",
+    buttonLabel: intl.string(t.RzWDqY),
+    onButtonPress: () => {
+      openUserSettings({
+        screen: UserSettingsSections.PREMIUM
+      });
+      c22250_0(ContentDismissActionType.TAKE_ACTION);
+    },
+    renderImgComponent: () => <ReferralProgramCoachmarkImg />
+  }), [visible, r32]);
+  return visible ? {
+    props: memo
+  } : null;
+}

modules/premium/referral_program/hooks/useIsEligibleSenderForReferralProgram.tsx

@@ -0,0 +1,8 @@
+// Metro module 7837 (f7838).
+import ReferralTrialStore from "../../ReferralTrialStore";
+import { useMaybeFetchReferralsRemaining } from "./useMaybeFetchReferralsRemaining";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+export function useIsEligibleSenderForReferralProgram(r7 = false) {
+  useMaybeFetchReferralsRemaining(r7);
+  return useStateFromStores([ReferralTrialStore], () => ReferralTrialStore.getIsEligibleToSendReferrals());
+}

modules/premium/referral_program/hooks/useMaybeFetchReferralsRemaining.tsx

@@ -0,0 +1,26 @@
+// Metro module 7838 (f7839).
+import { useEffect } from "react";
+import UserStore from "../../../../stores/UserStore";
+import ReferralTrialStore from "../../ReferralTrialStore";
+import { FractionalPremiumStates, PremiumTypes } from "../../PremiumConstants";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { useHasDiscountApplied } from "../../PremiumSubscriptionOfferUtil";
+import { useHasActiveTrial } from "../../PremiumSubscriptionTrialUtil";
+import useFractionalPremiumInfo from "../../../billing/hooks/useFractionalPremiumInfo";
+import { isPremiumExactly } from "../../../../utils/PremiumTypeUtils";
+export function useMaybeFetchReferralsRemaining(r6 = false) {
+  let c16032_1;
+  let c16032_0 = r6;
+  c16032_1 = void 0;
+  const stateFromStores = useStateFromStores([UserStore], () => UserStore.getCurrentUser());
+  const hasDiscountApplied = useHasDiscountApplied();
+  const hasActiveTrial = useHasActiveTrial();
+  const fractionalPremiumInfo = useFractionalPremiumInfo();
+  const r30 = stateFromStores?.verified === true && isPremiumExactly(stateFromStores, PremiumTypes.TIER_2) && fractionalPremiumInfo.fetched && fractionalPremiumInfo.fractionalState !== FractionalPremiumStates.FP_ONLY && !hasDiscountApplied && !hasActiveTrial;
+  c16032_1 = r30;
+  useEffect(() => {
+    if (c16032_1 && !c16032_0) {
+      ReferralTrialStore.checkAndFetchReferralsRemaining();
+    }
+  }, [r30, r6]);
+}

modules/premium/referral_program/hooks/useReferralProgramBannerDetails.tsx

@@ -0,0 +1,21 @@
+// Metro module 12474 (f12475).
+import { useEffect } from "react";
+import UserStore from "../../../../stores/UserStore";
+import ReferralTrialStore from "../../ReferralTrialStore";
+import { useStateFromStoresArray, useStateFromStores } from "../../../../_bundle/Module589";
+import { getUser } from "../../../../actions/UserActionCreators";
+export const MAX_REFERRALS_SENT = 3;
+export function useReferralProgramBannerDetails() {
+  const stateFromStoresArray = useStateFromStoresArray([ReferralTrialStore], () => ReferralTrialStore.getSentUserIds());
+  const stateFromStoresArray2 = useStateFromStoresArray([UserStore], () => stateFromStoresArray.map((item) => UserStore.getUser(item)).filter((item) => item != null));
+  useEffect(() => {
+    stateFromStoresArray.forEach((item) => {
+      getUser(item);
+    });
+  }, [stateFromStoresArray]);
+  return {
+    referralSentUsers: stateFromStoresArray2,
+    hasSentAllReferrals: stateFromStoresArray.length === 3,
+    refreshAt: useStateFromStores([ReferralTrialStore], () => ReferralTrialStore.getRefreshAt())
+  };
+}

modules/premium/referral_program/hooks/useReferralProgramEligibleUsers.tsx

@@ -0,0 +1,421 @@
+// Metro module 12477 (f12478).
+import _slicedToArray from "../../../../_bundle/_slicedToArray";
+import { useState, useRef, useEffect } from "react";
+import ReferralTrialStore from "../../ReferralTrialStore";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import Module38 from "../../../../_bundle/Module38";
+import { ReferralOfferStatus, fetchReferralEligibleUsers } from "../../ReferralTrialActionCreators";
+import { getUser } from "../../../../actions/UserActionCreators";
+import { HermesBuiltin } from "../../../../_hermes/prelude";
+function $mk118353($env) {
+  return (a0) => {
+    let r28;
+    const r6 = $env;
+    const r4 = $env.$parent;
+    let env32032 = {
+      $parent: r4
+    };
+    r6[2] = r6[2].filter($mk118891(r4));
+    env32032[0] = new Set(r6[2].map((item) => item.id));
+    const r26 = r6[7].users.filter((user) => {
+      const r7 = env32032.$parent[1].has(user.id);
+      return r7 ? !r7 : !env32032[0].has(user.id);
+    });
+    if (r6[0] === 0) {
+      const r35 = r4[1].values();
+      const r36 = [];
+      const r39 = HermesBuiltin.arraySpread(r36, r35, 0);
+      HermesBuiltin.arraySpread(r36, r26, HermesBuiltin.arraySpread(r36, r6[2].values(), r39));
+      r28 = r36;
+    } else {
+      r28 = [...a0, ...r26];
+    }
+    return r28;
+  };
+}
+function $mk118354($env) {
+  return (a0) => {
+    const map = new Map(a0);
+    for (const item of $env[2]) {
+      map.set(item.id, item);
+    }
+    return map;
+  };
+}
+function $mk118891($env) {
+  return (a0) => !$env[1].has(a0.id);
+}
+let env8623 = {};
+export function useReferralProgramEligibleUsers(a0) {
+  let env19859 = {
+    $parent: env8623
+  };
+  const searchQuery = a0.searchQuery;
+  env19859[0] = searchQuery;
+  env19859[1] = a0.selectedUsers;
+  const limit = a0.limit;
+  env19859[2] = limit;
+  env19859[3] = void 0;
+  env19859[4] = void 0;
+  env19859[5] = void 0;
+  env19859[6] = void 0;
+  env19859[7] = void 0;
+  env19859[8] = void 0;
+  env19859[9] = void 0;
+  env19859[10] = void 0;
+  env19859[11] = void 0;
+  env19859[12] = void 0;
+  env19859[13] = void 0;
+  env19859[17] = void 0;
+  env19859[18] = void 0;
+  env19859[14] = function _getLocalReferrals() {
+    const r9 = async () => {
+      let r29;
+      let c31657_0, c31657_1, c31657_2, c31657_3, c31657_4;
+      let c30522_0, c30522_1, c30522_4;
+      let c30522_5 = 0;
+      L23: {
+        L22: {
+          try {
+            c31657_0 = void 0;
+            c31657_1 = void 0;
+            c31657_2 = void 0;
+            c31657_3 = void 0;
+            c31657_4 = void 0;
+            c31657_0 = new Map();
+            const r42 = env19859[3];
+            c30522_1 = r42;
+            const r44 = r42[Symbol.iterator]();
+            c30522_1 = r44.next;
+            c30522_0 = r44;
+            while (true) {
+              const r46 = c30522_1;
+              let r47 = c30522_0;
+              const r48 = r47 === void 0 ? void 0 : (r29 = r46.call(r47)).done ? r47 = void 0 : r29.value;
+              c30522_0 = r47;
+              if (r47 === void 0) {
+                (0, env19859[13])(c31657_0);
+                (0, env19859[7])(Array.from(c31657_0.values()));
+                break L23;
+              }
+              c30522_5 = 1;
+              c31657_1 = r48;
+              c31657_2 = (0, _slicedToArray)(c31657_1, 2);
+              c31657_3 = c31657_2[0];
+              if (c31657_2[1] === ReferralOfferStatus.PENDING && !env19859[12].has(c31657_3)) {
+                let r98 = await getUser(c31657_3);
+                loop14: while (true) {
+                  c31657_4 = r98;
+                  c31657_0.set(c31657_4.id, c31657_4);
+                  while (true) {
+                    c30522_5 = 0;
+                    const r116 = c30522_1;
+                    let r117 = c30522_0;
+                    const r118 = r117 === void 0 ? void 0 : (r29 = r116.call(r117)).done ? r117 = void 0 : r29.value;
+                    c30522_0 = r117;
+                    if (r117 === void 0) {
+                      (0, env19859[13])(c31657_0);
+                      (0, env19859[7])(Array.from(c31657_0.values()));
+                      break L22;
+                    }
+                    c30522_5 = 1;
+                    c31657_1 = r118;
+                    c31657_2 = (0, _slicedToArray)(c31657_1, 2);
+                    c31657_3 = c31657_2[0];
+                    if (c31657_2[1] === ReferralOfferStatus.PENDING && !env19859[12].has(c31657_3)) {
+                      r98 = await getUser(c31657_3);
+                      continue loop14;
+                    }
+                  }
+                }
+              }
+              c30522_5 = 0;
+            }
+          } catch ($e) {
+            const r37 = $e;
+            let r7 = r37;
+            c30522_4 = r37;
+            if (c30522_5 !== 0) {
+              while (true) {
+                try {
+                  const r185 = c30522_4;
+                  c30522_5 = 0;
+                  const r187 = c30522_0;
+                  if (r187 !== void 0 && typeof r187.return === "function") {
+                    try {
+                      r187.return();
+                    } catch {}
+                  }
+                  throw r185;
+                } catch (r183) {
+                  r7 = r183;
+                  c30522_4 = r183;
+                  if (c30522_5 === 0) {
+                    break;
+                  }
+                }
+              }
+            }
+            throw r7;
+          }
+        }
+        return void 0;
+      }
+    };
+    env19859[14] = r9;
+    return r9.apply(this, arguments);
+  };
+  const getNextRows = function getNextRows(a0, a1) {
+    return env19859[16].apply(this, arguments);
+  };
+  env19859[15] = getNextRows;
+  env19859[16] = function _getNextRows() {
+    const r9 = async (c30523_0, c30523_1) => {
+      let r34, r148;
+      let c30523_2, c30523_3, c30523_4, c30523_5, c30523_6, c30523_7;
+      let c30523_8 = 0;
+      const r10 = env19859;
+      L43: {
+        L38: {
+          try {
+            let env31658;
+            c30523_6 = r10;
+            const r18 = env31658 = {
+              $parent: r10
+            };
+            c30523_5 = r18;
+            env31658[0] = c30523_0;
+            env31658[1] = c30523_1;
+            env31658[2] = void 0;
+            env31658[3] = void 0;
+            env31658[4] = void 0;
+            env31658[5] = void 0;
+            env31658[6] = void 0;
+            env31658[7] = void 0;
+            if (env19859[8]) {
+              break L43;
+            }
+            if (env19859[10]) {
+              break L43;
+            }
+            if (c30523_0 == null) {
+              break L43;
+            }
+            if (env19859[4] === 0) {
+              break L43;
+            }
+            c30523_8 = 2;
+            (0, env19859[9])(true);
+            c30523_2 = 0;
+            const r23 = env19859[12].values();
+            const r57 = [];
+            c30523_2 = HermesBuiltin.arraySpread(r57, r23, c30523_2);
+            env31658[2] = r57;
+            const r59 = env19859[3];
+            c30523_4 = r59;
+            const r61 = r59[Symbol.iterator]();
+            c30523_4 = r61.next;
+            c30523_3 = r61;
+            while (true) {
+              const r63 = c30523_4;
+              let r64 = c30523_3;
+              const r65 = r64 === void 0 ? void 0 : (r34 = r63.call(r64)).done ? r64 = void 0 : r34.value;
+              c30523_3 = r64;
+              if (r64 === void 0) {
+                const referralEligibleUsers = await fetchReferralEligibleUsers(env31658[0], env19859[0], env31658[1]);
+                const r308 = c30523_5;
+                env31658[7] = referralEligibleUsers;
+                (0, env19859[7])($mk118353(r308));
+                (0, env19859[13])($mk118354(r308));
+                (0, env19859[6])(env31658[7].nextIndex);
+                c30523_8 = 1;
+                c30523_8 = 0;
+                (0, env19859[9])(false);
+                break L38;
+              }
+              c30523_8 = 3;
+              env31658[3] = r65;
+              env31658[4] = (0, _slicedToArray)(env31658[3], 2);
+              env31658[5] = env31658[4][0];
+              if (env31658[4][1] === ReferralOfferStatus.PENDING && !env19859[12].has(env31658[5])) {
+                env31658[6] = await getUser(env31658[5]);
+                env31658[2].push(env31658[6]);
+                while (true) {
+                  c30523_8 = 2;
+                  L34: {
+                    const r134 = c30523_4;
+                    let r135 = c30523_3;
+                    const r136 = r135 === void 0 ? void 0 : (r34 = r134.call(r135)).done ? r135 = void 0 : r34.value;
+                    c30523_3 = r135;
+                    if (r135 === void 0) {
+                      r148 = fetchReferralEligibleUsers(env31658[0], env19859[0], env31658[1]);
+                    } else {
+                      c30523_8 = 3;
+                      env31658[3] = r136;
+                      env31658[4] = (0, _slicedToArray)(env31658[3], 2);
+                      env31658[5] = env31658[4][0];
+                      if (env31658[4][1] !== ReferralOfferStatus.PENDING) {
+                        continue;
+                      }
+                      if (env19859[12].has(env31658[5])) {
+                        continue;
+                      }
+                      let r181 = getUser(env31658[5]);
+                      loop26: while (true) {
+                        env31658[6] = await r181;
+                        env31658[2].push(env31658[6]);
+                        while (true) {
+                          c30523_8 = 2;
+                          const r207 = c30523_4;
+                          let r208 = c30523_3;
+                          const r209 = r208 === void 0 ? void 0 : (r34 = r207.call(r208)).done ? r208 = void 0 : r34.value;
+                          c30523_3 = r208;
+                          if (r208 === void 0) {
+                            r148 = fetchReferralEligibleUsers(env31658[0], env19859[0], env31658[1]);
+                            break L34;
+                          }
+                          c30523_8 = 3;
+                          env31658[3] = r209;
+                          env31658[4] = (0, _slicedToArray)(env31658[3], 2);
+                          env31658[5] = env31658[4][0];
+                          if (env31658[4][1] === ReferralOfferStatus.PENDING && !env19859[12].has(env31658[5])) {
+                            r181 = getUser(env31658[5]);
+                            continue loop26;
+                          }
+                        }
+                      }
+                    }
+                  }
+                  const r40 = await r148;
+                  const r273 = c30523_5;
+                  env31658[7] = r40;
+                  (0, env19859[7])($mk118353(r273));
+                  (0, env19859[13])($mk118354(r273));
+                  (0, env19859[6])(env31658[7].nextIndex);
+                  c30523_8 = 1;
+                  c30523_8 = 0;
+                  (0, env19859[9])(false);
+                  break L38;
+                }
+              }
+              c30523_8 = 2;
+            }
+            break L43;
+          } catch ($e) {
+            const r46 = $e;
+            let r7 = r46;
+            c30523_7 = r46;
+            let r47 = c30523_8;
+            if (r47 !== 0) {
+              while (true) {
+                if (r47 === 1) {
+                  try {
+                    const r346 = c30523_7;
+                    c30523_8 = 0;
+                    (0, env19859[9])(false);
+                    throw r346;
+                  } catch (r344) {
+                    r7 = r344;
+                    c30523_7 = r344;
+                    r47 = c30523_8;
+                    if (r47 === 0) {
+                      break;
+                    }
+                  }
+                } else if (r47 === 2) {
+                  try {
+                    c30523_8 = 1;
+                    (0, env19859[11])(true);
+                    c30523_8 = 0;
+                    (0, env19859[9])(false);
+                    break L38;
+                  } catch (r333) {
+                    r7 = r333;
+                    c30523_7 = r333;
+                    r47 = c30523_8;
+                    if (r47 === 0) {
+                      break;
+                    }
+                  }
+                } else {
+                  try {
+                    const r328 = c30523_7;
+                    c30523_8 = 2;
+                    const r330 = c30523_3;
+                    if (r330 !== void 0 && typeof r330.return === "function") {
+                      try {
+                        r330.return();
+                      } catch {}
+                    }
+                    throw r328;
+                  } catch (r327) {
+                    r7 = r327;
+                    c30523_7 = r327;
+                    r47 = c30523_8;
+                    if (r47 === 0) {
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+            throw r7;
+          }
+        }
+        return void 0;
+      }
+    };
+    env19859[16] = r9;
+    return r9.apply(this, arguments);
+  };
+  env19859[3] = useStateFromStores([ReferralTrialStore], () => ReferralTrialStore.getRecipientStatus());
+  const stateFromStores = useStateFromStores([ReferralTrialStore], () => ReferralTrialStore.getReferralsRemaining());
+  env19859[4] = stateFromStores;
+  const r37 = _slicedToArray(useState(0), 2);
+  env19859[5] = r37[0];
+  env19859[6] = r37[1];
+  const r43 = _slicedToArray(useState([]), 2);
+  const eligibleUsers = r43[0];
+  env19859[7] = r43[1];
+  const r48 = _slicedToArray(useState(false), 2);
+  const isFetching = r48[0];
+  env19859[8] = isFetching;
+  env19859[9] = r48[1];
+  const r53 = _slicedToArray(useState(false), 2);
+  const hasError = r53[0];
+  env19859[10] = hasError;
+  env19859[11] = r53[1];
+  const r61 = _slicedToArray(useState(new Map()), 2);
+  const resendUsers = r61[0];
+  env19859[12] = resendUsers;
+  env19859[13] = r61[1];
+  Module38(stateFromStores != null, "Referrals remaining should not be null");
+  const r71 = {
+    limit,
+    getNextRows,
+    getLocalReferrals: function getLocalReferrals() {
+      return env19859[14].apply(this, arguments);
+    }
+  };
+  env19859[17] = r71;
+  env19859[18] = useRef(r71);
+  useEffect(() => {
+    env19859[18].current = env19859[17];
+  });
+  useEffect(() => {
+    const current = env19859[18].current;
+    const { getNextRows: getNextRows2, limit, getLocalReferrals: getLocalReferrals2 } = current;
+    if (env19859[4] > 0) {
+      getNextRows2(0, limit);
+    } else {
+      getLocalReferrals2();
+    }
+  }, [searchQuery, stateFromStores]);
+  return {
+    eligibleUsers,
+    fetchUsers: () => (0, env19859[15])(env19859[5], env19859[2]),
+    hasError,
+    isFetching,
+    resendUsers
+  };
+}