yeet

modules/premium/tiered_tenure_badging/hooks/useMaybeFetchTieredTenureBadgeData.tsx

@@ -0,0 +1,17 @@
+// Metro module 12490 (f12491).
+import UserStore from "../../../../stores/UserStore";
+import { PremiumTypes } from "../../PremiumConstants";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { useIsPremiumSubscriber } from "../../useIsPremiumSubscriber";
+import useMountEffect from "../../../../hooks/useMountEffect";
+import maybeFetchUserProfile from "../../../user_profile/maybeFetchUserProfile";
+export function useMaybeFetchTieredTenureBadgeData() {
+  let isPremiumSubscriber;
+  const stateFromStores = useStateFromStores([UserStore], () => UserStore.getCurrentUser());
+  isPremiumSubscriber = useIsPremiumSubscriber(PremiumTypes.TIER_2);
+  useMountEffect(() => {
+    if (stateFromStores?.id != null && isPremiumSubscriber) {
+      maybeFetchUserProfile(stateFromStores.id);
+    }
+  });
+}

modules/premium/tiered_tenure_badging/hooks/useNextTenureBadge.tsx

@@ -0,0 +1,15 @@
+// Metro module 12471 (f12472).
+import { TENURE_BADGES, TIERED_TENURE_BADGE_ORDER } from "../../PremiumConstants";
+import { useTieredTenureBadgeData, TieredTenureBadgeStatus } from "./useTenureBadging";
+export function useNextTenureBadge() {
+  const tieredTenureBadgeData = useTieredTenureBadgeData();
+  if (tieredTenureBadgeData == null) {
+    return null;
+  }
+  if (tieredTenureBadgeData.status === TieredTenureBadgeStatus.UPCOMING) {
+    return tieredTenureBadgeData;
+  }
+  const r18 = TIERED_TENURE_BADGE_ORDER.indexOf(tieredTenureBadgeData.id);
+  const r20 = TIERED_TENURE_BADGE_ORDER[r18 + 1];
+  return r20 == null ? null : r18 !== -1 ? TENURE_BADGES[r20] : null;
+}

modules/premium/tiered_tenure_badging/hooks/useTenureBadgeRequirementString.tsx

@@ -0,0 +1,46 @@
+// Metro module 8423 (f8424).
+import { TieredTenureBadge } from "../../PremiumConstants";
+import { useTieredTenureBadge } from "./useTenureBadging";
+import { getTieredTenureBadgeData } from "../../../user_profile/TieredTenureBadgeUtils";
+import { intl, t } from "../../../../intl/index.native";
+export function useTenureBadgeRequirementString() {
+  let r27;
+  const tieredTenureBadge = useTieredTenureBadge();
+  if (tieredTenureBadge == null) {
+    return null;
+  }
+  L11: {
+    const tieredTenureBadgeData = getTieredTenureBadgeData(tieredTenureBadge);
+    const { id, tenureReqNumMonths } = tieredTenureBadgeData;
+    if (TieredTenureBadge.PREMIUM_TENURE_1_MONTH !== id && (TieredTenureBadge.PREMIUM_TENURE_3_MONTH !== id && TieredTenureBadge.PREMIUM_TENURE_6_MONTH !== id)) {
+      if (TieredTenureBadge.PREMIUM_TENURE_12_MONTH !== id && TieredTenureBadge.PREMIUM_TENURE_24_MONTH !== id && TieredTenureBadge.PREMIUM_TENURE_36_MONTH !== id && TieredTenureBadge.PREMIUM_TENURE_60_MONTH !== id) {
+        const PREMIUM_TENURE_72_MONTH = TieredTenureBadge.PREMIUM_TENURE_72_MONTH;
+        r27 = null;
+        if (PREMIUM_TENURE_72_MONTH !== id) {
+          break L11;
+        }
+      }
+      r27 = intl.formatToPlainString(t.qOdyDe, {
+        years: tenureReqNumMonths / 12
+      });
+    } else {
+      r27 = intl.formatToPlainString(t.erUSmA, {
+        months: tenureReqNumMonths
+      });
+    }
+  }
+  return r27;
+}
+export function getTenureBadgeRequirementString(a0, a1) {
+  if (TieredTenureBadge.PREMIUM_TENURE_1_MONTH !== a0 && TieredTenureBadge.PREMIUM_TENURE_3_MONTH !== a0 && TieredTenureBadge.PREMIUM_TENURE_6_MONTH !== a0) {
+    if (TieredTenureBadge.PREMIUM_TENURE_12_MONTH !== a0 && TieredTenureBadge.PREMIUM_TENURE_24_MONTH !== a0 && TieredTenureBadge.PREMIUM_TENURE_36_MONTH !== a0 && TieredTenureBadge.PREMIUM_TENURE_60_MONTH !== a0 && TieredTenureBadge.PREMIUM_TENURE_72_MONTH !== a0) {
+      return null;
+    }
+    return intl.formatToPlainString(t.qOdyDe, {
+      years: a1 / 12
+    });
+  }
+  return intl.formatToPlainString(t.erUSmA, {
+    months: a1
+  });
+}

modules/premium/tiered_tenure_badging/hooks/useTenureBadging.tsx

@@ -0,0 +1,113 @@
+// Metro module 8424 (f8425).
+import UserProfileStore from "../../../user_profile/UserProfileStore";
+import UserStore from "../../../../stores/UserStore";
+import SubscriptionStore from "../../../../stores/billing/SubscriptionStore";
+import { PremiumTypes, TENURE_BADGES } from "../../PremiumConstants";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { useTieredTenureBadgeForUser } from "./useTieredTenureBadgeForUser";
+import * as _PremiumTypeUtils from "../../../../utils/PremiumTypeUtils";
+import Module3771 from "../../../../_bundle/Module3771";
+import { getEarnedOnDate } from "../../../user_profile/TieredTenureBadgeUtils";
+function $mk80599($env) {
+  return () => {
+    const r4 = $env[0];
+    if (r4 == null) {
+      return null;
+    }
+    return $env.$parent[3].getUserProfile(r4)?.premiumSince;
+  };
+}
+let c5390_8;
+let $mk80598 = function() {
+  return () => UserStore.getCurrentUser();
+}, $mk80602 = function() {
+  return () => SubscriptionStore.getPremiumTypeSubscription();
+};
+let env5390 = {};
+export function usePremiumSince() {
+  let isPremiumExactly;
+  const stateFromStores = useStateFromStores([UserStore], () => UserStore.getCurrentUser());
+  isPremiumExactly = _PremiumTypeUtils.isPremiumExactly(stateFromStores, PremiumTypes.TIER_2);
+  let r27 = useStateFromStores([SubscriptionStore], () => {
+    const premiumSubscription = SubscriptionStore.getPremiumSubscription();
+    return premiumSubscription != null ? isPremiumExactly ? premiumSubscription.premiumSince : null : null;
+  }, [isPremiumExactly]);
+  const id = stateFromStores?.id;
+  let env16558;
+  const r29 = env16558 = {
+    $parent: env5390
+  };
+  env16558[0] = id;
+  const stateFromStores2 = useStateFromStores([UserProfileStore], $mk80599(r29));
+  if (r27 == null) {
+    r27 = stateFromStores2;
+  }
+  return r27;
+}
+c5390_8 = {
+  UPCOMING: "upcoming",
+  EARNED: "earned"
+};
+export { c5390_8 as TieredTenureBadgeStatus };
+export function useTieredTenureBadge() {
+  let r17 = useTieredTenureBadgeForUser(useStateFromStores([UserStore], $mk80598())?.id);
+  if (r17 == null) {
+    r17 = null;
+  }
+  return r17;
+}
+export function usePremiumSinceForUser(a0) {
+  let env16556;
+  const r1 = env16556 = {
+    $parent: env5390
+  };
+  env16556[0] = a0;
+  return useStateFromStores([UserProfileStore], $mk80599(r1));
+}
+export function useTieredTenureBadgesFromSubscriptionData() {
+  const r13 = Object.values(TENURE_BADGES);
+  const stateFromStores = useStateFromStores([UserStore], () => UserStore.getCurrentUser());
+  const stateFromStores2 = useStateFromStores([SubscriptionStore], () => SubscriptionStore.getPremiumTypeSubscription());
+  if (_PremiumTypeUtils.isPremiumExactly(stateFromStores, PremiumTypes.TIER_2) && stateFromStores2 != null && stateFromStores2.premiumSince != null) {
+    let c16559_0 = Module3771().diff(Module3771(stateFromStores2.premiumSince).add(1, "day"), "months");
+    return r13.reduce((r0, item) => {
+      const id = item.id;
+      if (c16559_0 >= item.tenureReqNumMonths) {
+        r0 = id;
+      }
+      return r0;
+    }, null);
+  }
+  return null;
+}
+export function useTieredTenureEarnedOnDate() {
+  let r18 = useTieredTenureBadgeForUser(useStateFromStores([UserStore], $mk80598())?.id);
+  if (r18 == null) {
+    r18 = null;
+  }
+  const stateFromStores = useStateFromStores([SubscriptionStore], $mk80602());
+  return r18 == null ? null : stateFromStores == null ? null : stateFromStores.premiumSince == null ? null : getEarnedOnDate(r18, stateFromStores.premiumSince);
+}
+export function useTieredTenureBadgeData() {
+  const tieredTenureBadgeForUser = useTieredTenureBadgeForUser(useStateFromStores([UserStore], () => UserStore.getCurrentUser())?.id);
+  const r23 = tieredTenureBadgeForUser == null ? null : TENURE_BADGES[tieredTenureBadgeForUser];
+  let r35 = useTieredTenureBadgeForUser(useStateFromStores([UserStore], $mk80598())?.id);
+  if (r35 == null) {
+    r35 = null;
+  }
+  const stateFromStores = useStateFromStores([SubscriptionStore], $mk80602());
+  const earnedOnDate = r35 == null ? null : stateFromStores == null ? null : stateFromStores.premiumSince == null ? null : getEarnedOnDate(r35, stateFromStores.premiumSince);
+  const premiumSince = usePremiumSince();
+  return r23 != null ? {
+    ...r23,
+    earnedOnDate,
+    status: c5390_8.EARNED
+  } : premiumSince != null ? {
+    ...Object.values(TENURE_BADGES)[0],
+    status: c5390_8.UPCOMING
+  } : null;
+}
+export function useTieredTenureBadgeDataForUser(a0) {
+  const tieredTenureBadgeForUser = useTieredTenureBadgeForUser(a0);
+  return tieredTenureBadgeForUser != null ? TENURE_BADGES[tieredTenureBadgeForUser] : null;
+}

modules/premium/tiered_tenure_badging/hooks/useTieredTenureBadgeForUser.tsx

@@ -0,0 +1,32 @@
+// Metro module 8425 (f8426).
+import UserProfileStore from "../../../user_profile/UserProfileStore";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { getTieredTenureBadge } from "../../../user_profile/TieredTenureBadgeUtils";
+export function useTieredTenureBadgeForUser(c16560_0) {
+  return useStateFromStores([UserProfileStore], () => {
+    const r4 = c16560_0 != null ? UserProfileStore.getUserProfile(c16560_0) : null;
+    const premiumSince = r4?.premiumSince;
+    const r10 = r4 == null;
+    let r11 = null;
+    if (!r10) {
+      const r12 = premiumSince == null;
+      r11 = null;
+      if (!r12) {
+        let tieredTenureBadge;
+        if (r4 != null) {
+          const badges = r4.badges;
+          if (badges != null) {
+            badges.forEach((badge) => {
+              const tieredTenureBadge2 = getTieredTenureBadge(badge.id);
+              if (tieredTenureBadge2 != null) {
+                tieredTenureBadge = tieredTenureBadge2;
+              }
+            });
+          }
+        }
+        r11 = tieredTenureBadge;
+      }
+    }
+    return r11;
+  });
+}

modules/premium/tiered_tenure_badging/hooks/useTimeUntilNextBadge.tsx

@@ -0,0 +1,23 @@
+// Metro module 12470 (f12471).
+import { useMemo } from "react";
+import Module3771 from "../../../../_bundle/Module3771";
+import { useNextTenureBadge } from "./useNextTenureBadge";
+import { usePremiumSince } from "./useTenureBadging";
+export function computeDaysUntilNextBadgeDate(a0, a1) {
+  return Math.max(0, Module3771(a0).add(a1, "months").add(1, "day").diff(Module3771(), "days"));
+}
+export function useTimeUntilNextBadge() {
+  const nextTenureBadge = useNextTenureBadge();
+  const premiumSince = usePremiumSince();
+  return useMemo(() => {
+    if (nextTenureBadge != null && premiumSince != null) {
+      const tenureReqNumMonths = nextTenureBadge.tenureReqNumMonths;
+      const r10 = Module3771(premiumSince).add(tenureReqNumMonths, "months").add(1, "day");
+      return {
+        days: Math.max(0, Module3771(premiumSince).add(tenureReqNumMonths, "months").add(1, "day").diff(Module3771(), "days")),
+        months: Math.max(0, Math.round(r10.diff(Module3771(), "months", true)))
+      };
+    }
+    return null;
+  }, [nextTenureBadge, premiumSince]);
+}