yeet

modules/premium/powerups/hooks/GuildPowerupsNotificationsDCF.native.tsx

@@ -0,0 +1,34 @@
+// Metro module 11593 (f11594).
+import { useSelectedDismissibleContent, useSelectedVersionedDismissibleContent, useSelectedTimeRecurringDismissibleContent, useSelectedTimeRecurringGuildDismissibleContent } from "../../../dismissible_content/hooks/useSelectedDismissibleContent";
+import { DismissibleContent } from "../../../../_bundle/Module1358";
+import { GUILD_POWERUP_NOTIFICATION_COOLDOWN, BOOST_TO_UNLOCK_COACHMARK_COOLDOWN, BOOST_TO_UNLOCK_COACHMARK_MAX_TIMES_TO_RECUR } from "../constants/GuildPowerupsNotification";
+import BoostToUnlockMobileCoachmarkExperiment from "../../../guild_boosting/experiments/BoostToUnlockMobileCoachmarkExperiment";
+export function usePerksCoachmarkDCF(a0) {
+  return useSelectedDismissibleContent(a0 ? [DismissibleContent.GUILD_POWERUP_PERKS_COACHMARK] : []);
+}
+export function useNewPerkAvailableCoachmarkDCF(a0, a1) {
+  return useSelectedVersionedDismissibleContent(a0 ? a1 > 0 ? DismissibleContent.GUILD_POWERUP_NEW_PERK_AVAILABLE_COACHMARK : null : null, a1);
+}
+export function useGuildPowerupNotificationDCF(a0) {
+  return useSelectedTimeRecurringDismissibleContent(a0 ? DismissibleContent.GUILD_POWERUP_NOTIFICATION : null, {
+    cooldownDurationMs: GUILD_POWERUP_NOTIFICATION_COOLDOWN
+  });
+}
+export function useNewGamesCoachmarkDC() {
+  return [null, () => {}];
+}
+export function useGameServerPricingCoachmarkDCF() {
+  return [null, () => {}];
+}
+export function useBoostToUnlockCoachmarkDCF(a0, a1, a2) {
+  const showCoachmark = BoostToUnlockMobileCoachmarkExperiment.useConfig({
+    location: "useBoostToUnlockCoachmarkDCF"
+  }).showCoachmark;
+  return useSelectedTimeRecurringGuildDismissibleContent(a0 ? showCoachmark ? DismissibleContent.BOOST_TO_UNLOCK_COACHMARK : null : null, a1, {
+    cooldownDurationMs: BOOST_TO_UNLOCK_COACHMARK_COOLDOWN,
+    numTimesToRecur: BOOST_TO_UNLOCK_COACHMARK_MAX_TIMES_TO_RECUR
+  }, a2);
+}
+export function useExpiringPowerupCoachmarkDCF() {
+  return [null, () => {}];
+}

modules/premium/powerups/hooks/useAvailableBoostCountForPowerup.tsx

@@ -0,0 +1,39 @@
+// Metro module 11627 (f11628).
+import { useMemo } from "react";
+import GuildStore from "../../../../stores/GuildStore";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { GuildPowerupType, LEVEL_SKU_ID_TO_BOOSTING_TIER, POWERUPS_INCLUDED_IN_LEVEL } from "../constants/GuildPowerupsConstants";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import useGuildPowerupsBoostCount from "./useGuildPowerupsBoostCount";
+import { isNotNullish } from "../../../../utils/GlobalUtils";
+export default function useAvailableBoostCountForPowerup(a0, a1) {
+  let stateFromStores;
+  const stateFromStores2 = useStateFromStores([GuildStore], () => GuildStore.getGuild(a0));
+  stateFromStores = useStateFromStores([GuildPowerupsStore], () => GuildPowerupsStore.getStateForGuild(a0));
+  const spent = useGuildPowerupsBoostCount(a0).spent;
+  const memo = useMemo(() => {
+    if (a1 != null && a1.type === GuildPowerupType.LEVEL && stateFromStores != null) {
+      const r12 = LEVEL_SKU_ID_TO_BOOSTING_TIER[a1.skuId];
+      let c27122_0 = r12;
+      return r12 == null ? [] : Object.entries(POWERUPS_INCLUDED_IN_LEVEL).filter((item) => {
+        const [r13, r14] = item;
+        return r14 === c27122_0 && stateFromStores.unlockedPowerups[r13] != null;
+      }).map((item) => {
+        const [r8] = item;
+        return stateFromStores.allPowerups[r8];
+      }).filter(isNotNullish);
+    }
+    return [];
+  }, [a1, stateFromStores]);
+  let r34 = memo == null ? void 0 : memo.reduce((acc, item) => acc + item.cost, 0);
+  const r38 = Math;
+  let r41 = stateFromStores2?.premiumSubscriberCount;
+  if (r41 == null) {
+    r41 = 0;
+  }
+  const r42 = r41 - spent;
+  if (r34 == null) {
+    r34 = 0;
+  }
+  return r38.max(r42 + r34, 0);
+};

modules/premium/powerups/hooks/useBoostToUnlockFeaturedPowerup.tsx

@@ -0,0 +1,66 @@
+// Metro module 11596 (f11597).
+import _slicedToArray from "../../../../_bundle/_slicedToArray";
+import { useState, useMemo } from "react";
+import GuildStore from "../../../../stores/GuildStore";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { GUILD_POWERUP_TIER_3_OVERRIDDEN_SKUS } from "../constants/GuildPowerupsConstants";
+import { GuildFeatures } from "../../../../Constants";
+import { GUILD_POWERUP_LEVEL_1_SKU_ID, GUILD_POWERUP_LEVEL_2_SKU_ID, GUILD_POWERUP_LEVEL_3_SKU_ID, GUILD_POWERUP_TAG_SKU_ID, GUILD_POWERUP_ROLE_COLOR_SKU_ID, GUILD_TAGS_BADGE_PACK_FLEX_POWERUP_SKU_ID, GUILD_TAGS_BADGE_PACK_PETS_POWERUP_SKU_ID } from "../../../../_bundle/Module4080";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import useGuildPowerupsBoostCount from "./useGuildPowerupsBoostCount";
+let c7912_9 = [{
+  skuId: GUILD_POWERUP_LEVEL_1_SKU_ID,
+  threshold: 1
+}, {
+  skuId: GUILD_POWERUP_LEVEL_2_SKU_ID,
+  threshold: 2
+}, {
+  skuId: GUILD_POWERUP_LEVEL_3_SKU_ID,
+  threshold: 2
+}, {
+  skuId: GUILD_POWERUP_TAG_SKU_ID,
+  threshold: 1
+}, {
+  skuId: GUILD_POWERUP_ROLE_COLOR_SKU_ID,
+  threshold: 1
+}, {
+  skuId: GUILD_TAGS_BADGE_PACK_FLEX_POWERUP_SKU_ID,
+  threshold: 1
+}, {
+  skuId: GUILD_TAGS_BADGE_PACK_PETS_POWERUP_SKU_ID,
+  threshold: 1
+}];
+export default function useBoostToUnlockFeaturedPowerup(a0) {
+  let available, stateFromStores2, state;
+  const stateFromStores = useStateFromStores([GuildPowerupsStore], () => GuildPowerupsStore.getStateForGuild(a0));
+  available = useGuildPowerupsBoostCount(a0).available;
+  stateFromStores2 = useStateFromStores([GuildStore], () => {
+    const guild = GuildStore.getGuild(a0);
+    return (guild == null ? void 0 : guild.features.has(GuildFeatures.PREMIUM_TIER_3_OVERRIDE)) === true;
+  });
+  state = _slicedToArray(useState(() => Math.random()), 1)[0];
+  return useMemo(() => {
+    if (stateFromStores != null) {
+      const { allPowerups, unlockedPowerups } = stateFromStores;
+      const r29 = [];
+      for (const item of c7912_9) {
+        const { skuId, threshold } = item;
+        const r36 = allPowerups[skuId];
+        if (r36 != null) {
+          if (stateFromStores2 && GUILD_POWERUP_TIER_3_OVERRIDDEN_SKUS.has(skuId)) {
+            continue;
+          }
+          if (unlockedPowerups[skuId] == null && r36.dependencies.every((dependency) => unlockedPowerups[dependency] != null)) {
+            const r52 = r36.cost - available;
+            if (r52 > 0 && r52 <= threshold) {
+              r29.push(r36);
+            }
+          }
+        }
+      }
+      if (r29.length > 0) {
+        return r29[Math.floor(state * r29.length)];
+      }
+    }
+  }, [stateFromStores, available, stateFromStores2, state]);
+};

modules/premium/powerups/hooks/useCanGuildPowerupBeToggled.tsx

@@ -0,0 +1,36 @@
+// Metro module 11624 (f11625).
+import { useMemo } from "react";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { PowerupActiveStatusType } from "../constants/GuildPowerupsConstants";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import usePowerupActiveStatus from "./usePowerupActiveStatus";
+import { intl } from "../../../../intl/index.native";
+import GuildPowerups_messages from "../GuildPowerups.messages";
+export default function useCanGuildPowerupBeToggled(a0, a1, a2) {
+  let c19035_4;
+  const stateFromStores = useStateFromStores([GuildPowerupsStore], () => GuildPowerupsStore.getStateForGuild(a0));
+  const powerupActiveStatus = usePowerupActiveStatus(a0, a1);
+  c19035_4 = powerupActiveStatus;
+  return useMemo(() => {
+    if (stateFromStores == null) {
+      return {
+        disabled: true,
+        reason: void 0
+      };
+    }
+    if (c19035_4.type !== PowerupActiveStatusType.LEVEL_ACTIVATED && c19035_4.type !== PowerupActiveStatusType.TIER_OVERRIDE_ACTIVATED) {
+      const { allPowerups, unlockedPowerups } = stateFromStores;
+      const r21 = a2 ? Object.values(unlockedPowerups).find((item) => item.sku?.dependent_sku_id === a1.skuId)?.sku_id : a1.dependencies.find((dependency) => unlockedPowerups[dependency] == null);
+      return {
+        disabled: r21 != null,
+        reason: r21 != null ? allPowerups[r21] != null ? intl.formatToPlainString(a2 ? GuildPowerups_messages.vCEBiS : GuildPowerups_messages["1B8AZr"], {
+          perk: allPowerups[r21]?.title
+        }) : void 0 : void 0
+      };
+    }
+    return {
+      disabled: true,
+      reason: void 0
+    };
+  }, [stateFromStores, a1.skuId, a1.dependencies, a2, powerupActiveStatus.type]);
+};

modules/premium/powerups/hooks/useCanPurchaseBoosts.tsx

@@ -0,0 +1,13 @@
+// Metro module 11597 (f11598).
+import UserStore from "../../../../stores/UserStore";
+import { FractionalPremiumStates } from "../../PremiumConstants";
+import useFractionalPremiumInfo from "../../../billing/hooks/useFractionalPremiumInfo";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+export default function useCanPurchaseBoosts() {
+  const fractionalState = useFractionalPremiumInfo().fractionalState;
+  const stateFromStores = useStateFromStores([UserStore], () => {
+    const currentUser = UserStore.getCurrentUser();
+    return (currentUser == null ? void 0 : currentUser.isPremiumGroupMember()) === true;
+  });
+  return fractionalState === FractionalPremiumStates.NONE && !stateFromStores;
+};

modules/premium/powerups/hooks/useDeactivateWarningText.tsx

@@ -0,0 +1,75 @@
+// Metro module 11633 (f11634).
+import { useMemo } from "react";
+import GuildMemberCountStore from "../../../../stores/GuildMemberCountStore";
+import GuildRoleStore from "../../../../stores/GuildRoleStore";
+import GuildStore from "../../../../stores/GuildStore";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import useGuildRoleMemberCounts from "../../../guild_role_subscriptions/useGuildRoleMemberCounts";
+import { GUILD_POWERUP_ROLE_COLOR_SKU_ID, VANITY_URL_POWERUP_SKU_ID, GUILD_TAGS_BADGE_PACK_PETS_POWERUP_SKU_ID, GUILD_TAGS_BADGE_PACK_FLEX_POWERUP_SKU_ID, GUILD_TAGS_BADGE_PACK_PLANT_POWERUP_SKU_ID, GUILD_TAGS_BADGE_PACK_CREEPY_CRAWLIES_POWERUP_SKU_ID, GUILD_POWERUP_LEVEL_3_SKU_ID } from "../../../../_bundle/Module4080";
+import { intl } from "../../../../intl/index.native";
+import GuildPowerups_messages from "../GuildPowerups.messages";
+export default function useDeactivateWarningText(a0, a1) {
+  let c19044_3, stateFromStores2, stateFromStores3;
+  const stateFromStores = useStateFromStores([GuildMemberCountStore], () => GuildMemberCountStore.getMemberCount(a0));
+  const guildRoleMemberCounts = useGuildRoleMemberCounts(a0);
+  c19044_3 = guildRoleMemberCounts;
+  stateFromStores2 = useStateFromStores([GuildStore], () => GuildStore.getGuild(a0)?.vanityURLCode != null);
+  stateFromStores3 = useStateFromStores([GuildRoleStore], () => a1.skuId === GUILD_POWERUP_ROLE_COLOR_SKU_ID ? c19044_3 == null ? 0 : GuildRoleStore.getSortedRoles(a0).reduce((acc, item) => {
+    const secondaryColor = item.colorStrings?.secondaryColor;
+    let r7 = acc;
+    if (secondaryColor != null) {
+      let r11 = c19044_3[item.id];
+      if (r11 == null) {
+        r11 = 0;
+      }
+      r7 = acc + r11;
+    }
+    return r7;
+  }, 0) : 0, [a0, a1.skuId, guildRoleMemberCounts]);
+  return useMemo(() => {
+    let r5, text;
+    L18: {
+      r5 = a1;
+      const skuId = r5.skuId;
+      if (GUILD_POWERUP_ROLE_COLOR_SKU_ID === skuId) {
+        text = stateFromStores3 > 0 ? intl.formatToPlainString(GuildPowerups_messages["4jSvr1"], {
+          perk: r5.title,
+          memberCount: stateFromStores3
+        }) : intl.formatToPlainString(GuildPowerups_messages.cavtEo, {
+          perk: r5.title
+        });
+      } else if (VANITY_URL_POWERUP_SKU_ID === skuId) {
+        text = stateFromStores2 ? intl.string(GuildPowerups_messages.hN75yb) : intl.string(GuildPowerups_messages.Du91Rb);
+      } else {
+        if (GUILD_TAGS_BADGE_PACK_PETS_POWERUP_SKU_ID !== skuId && GUILD_TAGS_BADGE_PACK_FLEX_POWERUP_SKU_ID !== skuId && GUILD_TAGS_BADGE_PACK_PLANT_POWERUP_SKU_ID !== skuId && GUILD_TAGS_BADGE_PACK_CREEPY_CRAWLIES_POWERUP_SKU_ID !== skuId) {
+          const r9 = GuildPowerups_messages["4jSvr1"];
+          let memberCount = stateFromStores;
+          if (stateFromStores == null) {
+            memberCount = 0;
+          }
+          text = intl.formatToPlainString(r9, {
+            perk: r5.title,
+            memberCount
+          });
+          break L18;
+        }
+        text = intl.string(GuildPowerups_messages.Vf2ZcR);
+      }
+    }
+    const r93 = [{
+      text,
+      critical: r5.skuId === VANITY_URL_POWERUP_SKU_ID
+    }];
+    let r94 = stateFromStores2;
+    if (stateFromStores2) {
+      r94 = r5.skuId === GUILD_POWERUP_LEVEL_3_SKU_ID;
+    }
+    if (r94) {
+      r93.push({
+        text: intl.string(GuildPowerups_messages.M4XL5n),
+        critical: true
+      });
+    }
+    return r93;
+  }, [a1, stateFromStores3, stateFromStores, stateFromStores2]);
+};

modules/premium/powerups/hooks/useFeaturedExpiringPowerup.tsx

@@ -0,0 +1,78 @@
+// Metro module 11598 (f11599).
+import { useMemo } from "react";
+import GameServerStore from "../../game_server/GameServerStore";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { useExpiringPowerupCoachmarkEnabled } from "../experiments/ExpiringPowerupCoachmarkExperiment";
+import { getDaysRemaining } from "../../../collectibles/CollectiblesUtils";
+import { HermesBuiltin } from "../../../../_hermes/prelude";
+export default function useFeaturedExpiringPowerup(c19020_0) {
+  let stateFromStores2, expiringPowerupCoachmarkEnabled;
+  const stateFromStores = useStateFromStores([GuildPowerupsStore], () => GuildPowerupsStore.getStateForGuild(c19020_0));
+  stateFromStores2 = useStateFromStores([GameServerStore], () => GameServerStore.getStateForGuild(c19020_0));
+  expiringPowerupCoachmarkEnabled = useExpiringPowerupCoachmarkEnabled("useFeaturedExpiringPowerup");
+  return useMemo(() => {
+    L21: {
+      if (expiringPowerupCoachmarkEnabled) {
+        const r11 = Object;
+        let r9 = stateFromStores?.unlockedPowerups;
+        if (r9 == null) {
+          r9 = {};
+        }
+        const r16 = r11.values(r9);
+        const r20 = [];
+        const r1 = HermesBuiltin.arraySpread(r20, r16, 0);
+        const r21 = Object;
+        let r24 = stateFromStores2?.entitlements;
+        if (r24 == null) {
+          r24 = {};
+        }
+        HermesBuiltin.arraySpread(r20, r21.values(r24), r1);
+        const r31 = r20.filter((item) => {
+          let r1 = item.ends_at != null;
+          if (r1) {
+            let r7 = item.metadata?.num_expiring_boosts;
+            if (r7 == null) {
+              r7 = 0;
+            }
+            r1 = r7 > 0;
+          }
+          return r1;
+        });
+        if (r31.length !== 0) {
+          const r35 = r31.reduce((acc, item) => item.ends_at > acc.ends_at ? item : acc);
+          let name = stateFromStores == null ? void 0 : stateFromStores.allPowerups[r35.sku_id]?.title;
+          if (name == null) {
+            name = null;
+          }
+          const sku = r35.sku;
+          const r43 = sku == null;
+          let r44 = void 0;
+          if (!r43) {
+            const tenant_metadata = sku.tenant_metadata;
+            r44 = tenant_metadata == null ? void 0 : tenant_metadata.guild_monetization?.game_server;
+          }
+          const isGameServer = r44 != null;
+          if (name === null && !isGameServer) {
+            break L21;
+          }
+          const r50 = {
+            name,
+            daysUntilExpiry: Math.max(0, getDaysRemaining(new Date(r35.ends_at))),
+            numExpiringBoosts: null,
+            isGameServer: null,
+            skuId: null
+          };
+          let numExpiringBoosts = r35.metadata?.num_expiring_boosts;
+          if (numExpiringBoosts == null) {
+            numExpiringBoosts = 0;
+          }
+          r50.numExpiringBoosts = numExpiringBoosts;
+          r50.isGameServer = isGameServer;
+          r50.skuId = r35.sku_id;
+          return r50;
+        }
+      }
+    }
+  }, [stateFromStores, stateFromStores2, expiringPowerupCoachmarkEnabled]);
+};

modules/premium/powerups/hooks/useGetExpiringGuildPowerups.tsx

@@ -0,0 +1,16 @@
+// Metro module 11649 (f11650).
+import { useMemo } from "react";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { getExpiringGuildEntitlements } from "../utils/getExpiringGuildEntitlements";
+import { isNotNullish } from "../../../../utils/GlobalUtils";
+export default function useGetExpiringGuildPowerups(c19051_0) {
+  const stateFromStores = useStateFromStores([GuildPowerupsStore], () => GuildPowerupsStore.getStateForGuild(c19051_0));
+  return useMemo(() => {
+    if (stateFromStores == null) {
+      return [];
+    }
+    const allPowerups = stateFromStores.allPowerups;
+    return getExpiringGuildEntitlements(Object.values(stateFromStores.unlockedPowerups)).map((item) => allPowerups[item.sku_id]).filter(isNotNullish);
+  }, [stateFromStores]);
+};

modules/premium/powerups/hooks/useGetGuildPowerupBannerImage.tsx

@@ -0,0 +1,41 @@
+// Metro module 11612 (f11613).
+import AccessibilityStore from "../../../a11y/AccessibilityStore";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+export default function useGetGuildPowerupBannerImage(a0, a1, a2) {
+  let animatedImageUrl;
+  const stateFromStores = useStateFromStores([AccessibilityStore], () => AccessibilityStore.useReducedMotion);
+  const r1 = a0 != null;
+  let r14 = void 0;
+  if (r1) {
+    L8: {
+      if (!stateFromStores && (a1 !== false && !a2)) {
+        animatedImageUrl = a0.animatedImageUrl;
+        if (animatedImageUrl != null) {
+          break L8;
+        }
+        animatedImageUrl = a0.staticImageUrl;
+      } else {
+        animatedImageUrl = a0.staticImageUrl;
+      }
+    }
+    r14 = animatedImageUrl;
+  }
+  return r14;
+};
+export function getGuildPowerupBannerImage(a0, a1, a2, a3) {
+  let animatedImageUrl;
+  if (a0 != null) {
+    L9: {
+      if (!a1 && (a2 !== false && !a3)) {
+        animatedImageUrl = a0.animatedImageUrl;
+        if (animatedImageUrl != null) {
+          break L9;
+        }
+        animatedImageUrl = a0.staticImageUrl;
+      } else {
+        animatedImageUrl = a0.staticImageUrl;
+      }
+    }
+    return animatedImageUrl;
+  }
+}

modules/premium/powerups/hooks/useGuildPowerupCardFooterConfig.tsx

@@ -0,0 +1,26 @@
+// Metro module 11623 (f11624).
+import GuildStore from "../../../../stores/GuildStore";
+import { GUILD_POWERUP_CONFIGURABLE_SKUS_MOBILE, PowerupActiveStatusType, GUILD_POWERUP_CONFIGURABLE_SKUS_DESKTOP } from "../constants/GuildPowerupsConstants";
+import { GuildFeatures } from "../../../../Constants";
+import usePowerupActiveStatus from "./usePowerupActiveStatus";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { GUILD_POWERUP_GUILD_THEME_SKU_ID } from "../../../../_bundle/Module4080";
+import useGuildPowerupRollbackEnabled from "./useGuildPowerupRollbackEnabled";
+GUILD_POWERUP_CONFIGURABLE_SKUS_DESKTOP;
+export default function useGuildPowerupCardFooterConfig(a0, a1) {
+  const powerupActiveStatus = usePowerupActiveStatus(a0, a1);
+  const stateFromStores = useStateFromStores([GuildStore], () => {
+    const guild = GuildStore.getGuild(a0);
+    return (guild == null ? void 0 : guild.features.has(GuildFeatures.GUILD_THEME)) === true;
+  }, [a0]);
+  const skuId = a1.skuId;
+  const isPowerupActive = powerupActiveStatus.type !== PowerupActiveStatusType.INACTIVE || skuId === GUILD_POWERUP_GUILD_THEME_SKU_ID && stateFromStores;
+  const type = powerupActiveStatus.type;
+  const TIER_OVERRIDE_ACTIVATED = PowerupActiveStatusType.TIER_OVERRIDE_ACTIVATED;
+  const guildPowerupRollbackEnabled = useGuildPowerupRollbackEnabled(a0, a1, "GuildPowerupCardFooterAdmin");
+  return {
+    showToggleButton: (isPowerupActive ? isPowerupActive : !guildPowerupRollbackEnabled) && !(type === TIER_OVERRIDE_ACTIVATED),
+    showConfigureButton: isPowerupActive && GUILD_POWERUP_CONFIGURABLE_SKUS_MOBILE.has(a1.skuId),
+    isPowerupActive
+  };
+};

modules/premium/powerups/hooks/useGuildPowerupExpiringNotificationsConfig.tsx

@@ -0,0 +1,35 @@
+// Metro module 11648 (f11649).
+import useGetExpiringGuildPowerups from "./useGetExpiringGuildPowerups";
+import useGameServerGetExpiringEntitlements from "../../game_server/hooks/useGameServerGetExpiringEntitlements";
+import { intl } from "../../../../intl/index.native";
+import GameServer_messages from "../../game_server/GameServer.messages";
+import { VANITY_URL_POWERUP_SKU_ID } from "../../../../_bundle/Module4080";
+import GuildPowerups_messages from "../GuildPowerups.messages";
+export default function useGuildPowerupExpiringNotificationsConfig(a0) {
+  const getExpiringGuildPowerups = useGetExpiringGuildPowerups(a0);
+  const gameServerGetExpiringEntitlements = useGameServerGetExpiringEntitlements(a0);
+  const shouldShow = getExpiringGuildPowerups.length > 0 || gameServerGetExpiringEntitlements.length > 0;
+  if (shouldShow) {
+    const r13 = gameServerGetExpiringEntitlements.length > 0 ? intl.string(GameServer_messages["B3OfL/"]) : void 0;
+    const expiringPowerupNames = [...getExpiringGuildPowerups.map((getExpiringGuildPowerup) => getExpiringGuildPowerup.title), ...r13 != null ? [r13] : []];
+    const warnings = [];
+    if (getExpiringGuildPowerups.some((getExpiringGuildPowerup) => getExpiringGuildPowerup.skuId === VANITY_URL_POWERUP_SKU_ID)) {
+      warnings.push(intl.string(GuildPowerups_messages.Sfr0Jw));
+    }
+    if (gameServerGetExpiringEntitlements.length > 0) {
+      warnings.push(intl.string(GameServer_messages.wiungr));
+    }
+    return {
+      shouldShow,
+      expiringPowerups: getExpiringGuildPowerups,
+      expiringPowerupNames,
+      warnings
+    };
+  }
+  return {
+    shouldShow: false,
+    expiringPowerups: [],
+    expiringPowerupNames: [],
+    warnings: []
+  };
+};

modules/premium/powerups/hooks/useGuildPowerupLevelPerks.tsx

@@ -0,0 +1,52 @@
+// Metro module 11618 (f11619).
+import { useMemo } from "react";
+import { GUILD_FEATURE_TO_PERK } from "../constants/GuildPowerupsConstants";
+import { PerkIcons } from "../../../../utils/GuildBoostingUtils";
+import { intl } from "../../../../intl/index.native";
+import GuildPowerups_messages from "../GuildPowerups.messages";
+import { isNotNullish } from "../../../../utils/GlobalUtils";
+export default function useGuildPowerupLevelPerks(a0) {
+  let r3 = arguments[1];
+  if (r3 === void 0) {
+    r3 = {
+      includeEmojis: true,
+      includeStickers: true,
+      includeSoundboards: true
+    };
+  }
+  const { includeEmojis, includeStickers, includeSoundboards } = r3;
+  return useMemo(() => {
+    const r3 = [];
+    let c27119_0 = GUILD_FEATURE_TO_PERK();
+    if (includeEmojis) {
+      const r25 = GuildPowerups_messages["NXvV0+"];
+      r3.push({
+        perkIcon: PerkIcons.EMOJI,
+        description: intl.formatToPlainString(r25, {
+          totalEmojis: a0.features.total_emoji_slots,
+          additionalEmojis: a0.features.additional_emoji_slots
+        })
+      });
+    }
+    if (includeStickers) {
+      r3.push({
+        perkIcon: PerkIcons.STICKER,
+        description: intl.formatToPlainString(GuildPowerups_messages.ZEvvPz, {
+          totalStickers: a0.features.total_sticker_slots,
+          additionalStickers: a0.features.additional_sticker_slots
+        })
+      });
+    }
+    if (includeSoundboards) {
+      const r73 = GuildPowerups_messages["s9u/E7"];
+      r3.push({
+        perkIcon: PerkIcons.SOUNDBOARD,
+        description: intl.formatToPlainString(r73, {
+          totalSoundboards: a0.features.total_sound_slots,
+          additionalSoundboards: a0.features.additional_sound_slots
+        })
+      });
+    }
+    return r3.concat(a0.features.features.map((feature) => c27119_0[feature]).filter(isNotNullish));
+  }, [a0, includeEmojis, includeStickers, includeSoundboards]);
+};

modules/premium/powerups/hooks/useGuildPowerupNewPerkMarketingVersion.tsx

@@ -0,0 +1,94 @@
+// Metro module 11595 (f11596).
+import { useMemo } from "react";
+import GuildStore from "../../../../stores/GuildStore";
+import PermissionStore from "../../../../stores/PermissionStore";
+import { GuildPowerupNewPerkMarketingVersion, NEW_PERK_MARKETING_VERSION_TO_POWERUP_SKU_ID_SET } from "../constants/GuildPowerupsConstants";
+import { GuildFeatures, Permissions } from "../../../../Constants";
+import { useGameServerEnabled } from "../../game_server/GameServerExperiment";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { useServerThemeEnabled } from "../experiments/ServerThemeExperiment";
+import { useServerThemeUserEnabled } from "../experiments/ServerThemeUserExperiment";
+import { GUILD_POWERUP_TAG_SKU_ID, GUILD_POWERUP_GUILD_THEME_SKU_ID, GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID } from "../../../../_bundle/Module4080";
+import { canUseMobileServerTagSettings } from "../../../guild_settings/GuildSettingsServerTagUtils";
+export default function useGuildPowerupNewPerkMarketingVersion(a0, a1) {
+  let serverThemeUserEnabled, stateFromStores2;
+  const gameServerEnabled = useGameServerEnabled(a0, "useGuildPowerupNewPerkMarketingVersion");
+  const stateFromStores = useStateFromStores([GuildStore], () => {
+    const guild = GuildStore.getGuild(a0);
+    return guild == null ? void 0 : guild.features.has(GuildFeatures.GAME_SERVERS);
+  });
+  let r22 = useServerThemeEnabled(a0, "useGuildPowerupNewPerkMarketingVersion");
+  const serverThemeUserEnabled2 = useServerThemeUserEnabled("useGuildPowerupNewPerkMarketingVersion");
+  if (r22) {
+    r22 = serverThemeUserEnabled2;
+  }
+  serverThemeUserEnabled = r22;
+  stateFromStores2 = useStateFromStores([PermissionStore, GuildStore], () => PermissionStore.can(Permissions.MANAGE_GUILD, GuildStore.getGuild(a0)));
+  return useMemo(() => {
+    const r2 = a1 == null;
+    let r4 = void 0;
+    if (!r2) {
+      const allPowerups = a1.allPowerups;
+      r4 = allPowerups == null ? void 0 : allPowerups[GUILD_POWERUP_TAG_SKU_ID];
+    }
+    const r3 = r4 != null;
+    const r18 = a1 == null;
+    let r19 = void 0;
+    if (!r18) {
+      const unlockedPowerups = a1.unlockedPowerups;
+      r19 = unlockedPowerups == null ? void 0 : unlockedPowerups[GUILD_POWERUP_TAG_SKU_ID];
+    }
+    const r28 = r19 != null;
+    if (r3 && !r28 && stateFromStores2 && canUseMobileServerTagSettings(a0)) {
+      return GuildPowerupNewPerkMarketingVersion.GUILD_TAG;
+    }
+    const r40 = a1 == null;
+    let r41 = void 0;
+    if (!r40) {
+      const allPowerups2 = a1.allPowerups;
+      r41 = allPowerups2 == null ? void 0 : allPowerups2[GUILD_POWERUP_GUILD_THEME_SKU_ID];
+    }
+    const r50 = r41 != null;
+    const r51 = a1 == null;
+    let r52 = void 0;
+    if (!r51) {
+      const unlockedPowerups2 = a1.unlockedPowerups;
+      r52 = unlockedPowerups2 == null ? void 0 : unlockedPowerups2[GUILD_POWERUP_GUILD_THEME_SKU_ID];
+    }
+    const r61 = r52 != null;
+    if (serverThemeUserEnabled && r50 && !r61) {
+      return GuildPowerupNewPerkMarketingVersion.GUILD_THEME;
+    }
+    const r66 = a1 == null;
+    let r67 = void 0;
+    if (!r66) {
+      const allPowerups3 = a1.allPowerups;
+      r67 = allPowerups3 == null ? void 0 : allPowerups3[GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID];
+    }
+    const r76 = r67 != null;
+    const r77 = a1 == null;
+    let r78 = void 0;
+    if (!r77) {
+      const unlockedPowerups3 = a1.unlockedPowerups;
+      r78 = unlockedPowerups3 == null ? void 0 : unlockedPowerups3[GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID];
+    }
+    const r87 = r78 != null;
+    return r76 && !r87 ? GuildPowerupNewPerkMarketingVersion.FILE_UPLOAD_250_MB : Array.from(NEW_PERK_MARKETING_VERSION_TO_POWERUP_SKU_ID_SET[GuildPowerupNewPerkMarketingVersion.GUILD_TAG_BADGE_PACKS_WAVE_TWO]).some((item) => {
+      const r2 = a1 == null;
+      let r6 = void 0;
+      if (!r2) {
+        const unlockedPowerups = a1.unlockedPowerups;
+        r6 = unlockedPowerups == null ? void 0 : unlockedPowerups[item];
+      }
+      return r6 != null;
+    }) ? gameServerEnabled && !stateFromStores ? GuildPowerupNewPerkMarketingVersion.GAME_SERVER_HOSTING : Array.from(NEW_PERK_MARKETING_VERSION_TO_POWERUP_SKU_ID_SET[GuildPowerupNewPerkMarketingVersion.GUILD_TAG_BADGE_PACKS_WAVE_ONE]).some((item) => {
+      const r2 = a1 == null;
+      let r6 = void 0;
+      if (!r2) {
+        const unlockedPowerups = a1.unlockedPowerups;
+        r6 = unlockedPowerups == null ? void 0 : unlockedPowerups[item];
+      }
+      return r6 != null;
+    }) ? 0 : GuildPowerupNewPerkMarketingVersion.GUILD_TAG_BADGE_PACKS_WAVE_ONE : GuildPowerupNewPerkMarketingVersion.GUILD_TAG_BADGE_PACKS_WAVE_TWO;
+  }, [a1, gameServerEnabled, stateFromStores, serverThemeUserEnabled, a0, stateFromStores2]);
+};

modules/premium/powerups/hooks/useGuildPowerupOnDeactivate.tsx

@@ -0,0 +1,12 @@
+// Metro module 11632 (f11633).
+import { useCallback } from "react";
+import useGuildPowerupOnToggle from "./useGuildPowerupOnToggle";
+export default function useGuildPowerupOnDeactivate(a0, a1) {
+  const guildPowerupOnToggle = useGuildPowerupOnToggle(a0, a1);
+  const { isLoading, error, onToggle } = guildPowerupOnToggle;
+  return {
+    isLoading,
+    error,
+    onDeactivate: useCallback(() => onToggle(false), [onToggle])
+  };
+};

modules/premium/powerups/hooks/useGuildPowerupOnToggle.tsx

@@ -0,0 +1,30 @@
+// Metro module 11626 (f11627).
+import { useState, useCallback } from "react";
+import { enablePowerupForGuild, disablePowerupForGuild } from "../GuildPowerupsActionCreators";
+export default function useGuildPowerupOnToggle(a0, a1) {
+  let c19037_0 = a0;
+  const [isLoading, setState] = useState(false);
+  const [error, setState2] = useState(void 0);
+  return {
+    isLoading,
+    error,
+    onToggle: useCallback((a0) => {
+      if (a1 == null) {
+        return Promise.resolve();
+      }
+      const r11 = a0 ? enablePowerupForGuild : disablePowerupForGuild;
+      setState(true);
+      setState2(void 0);
+      return r11(c19037_0, a1.skuId).catch((error) => {
+        let r7 = error.body?.message;
+        if (r7 == null) {
+          r7 = void 0;
+        }
+        setState2(r7);
+        throw error;
+      }).finally(() => {
+        setState(false);
+      });
+    }, [a0, a1])
+  };
+};

modules/premium/powerups/hooks/useGuildPowerupRollbackEnabled.tsx

@@ -0,0 +1,10 @@
+// Metro module 11588 (f11589).
+import { useFileUpload250MbPowerupRollbackEnabled, getFileUpload250MbPowerupRollbackEnabled } from "../experiments/FileUpload250MbPowerupExperiment";
+import { GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID } from "../../../../_bundle/Module4080";
+export default function useGuildPowerupRollbackEnabled(a0, a1, a2) {
+  const fileUpload250MbPowerupRollbackEnabled = useFileUpload250MbPowerupRollbackEnabled(a0, a2);
+  return a1.skuId === GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID && fileUpload250MbPowerupRollbackEnabled;
+};
+export function isGuildPowerupRollbackEnabled(a0, a1, a2) {
+  return a1.skuId === GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID && getFileUpload250MbPowerupRollbackEnabled(a0, a2);
+}

modules/premium/powerups/hooks/useGuildPowerupRollbackModalConfig.tsx

@@ -0,0 +1,61 @@
+// Metro module 11604 (f11605).
+import { useMemo } from "react";
+import GuildStore from "../../../../stores/GuildStore";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import useHasAllocateBoostPermission from "./useHasAllocateBoostPermission";
+import { GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID } from "../../../../_bundle/Module4080";
+import { useShouldShowFileUploadRollback } from "../utils/fileUpload";
+import getGuildPowerupFormattedDateString from "../utils/getGuildPowerupFormattedDateString";
+import { DismissibleContent } from "../../../../_bundle/Module1358";
+import { intl } from "../../../../intl/index.native";
+import GuildPowerups_messages from "../GuildPowerups.messages";
+export default function useGuildPowerupRollbackModalConfig(a0, a1) {
+  let c19026_1, storeRemovalDate, c19026_3;
+  const stateFromStores = useStateFromStores([GuildStore], () => GuildStore.getGuild(a0));
+  let shouldShow = useHasAllocateBoostPermission(a0);
+  if (shouldShow == null) {
+    shouldShow = false;
+  }
+  const stateFromStores2 = useStateFromStores([GuildPowerupsStore], () => GuildPowerupsStore.getStateForGuild(a0));
+  const r2 = stateFromStores2 == null;
+  let r26 = void 0;
+  if (!r2) {
+    const allPowerups = stateFromStores2.allPowerups;
+    r26 = allPowerups == null ? void 0 : allPowerups[GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID];
+  }
+  c19026_1 = r26;
+  storeRemovalDate = r26?.storeRemovalDate;
+  const shouldShowFileUploadRollback = useShouldShowFileUploadRollback(a0, a1);
+  if (shouldShow) {
+    shouldShow = shouldShowFileUploadRollback;
+  }
+  if (shouldShow) {
+    shouldShow = stateFromStores != null;
+  }
+  c19026_3 = shouldShow;
+  return {
+    shouldShow,
+    modalConfig: useMemo(() => {
+      if (c19026_3) {
+        if (c19026_1 != null && storeRemovalDate != null) {
+          const guildPowerupFormattedDateString = getGuildPowerupFormattedDateString(storeRemovalDate);
+          return {
+            dismissibleContent: DismissibleContent.FILE_UPLOAD_POWERUP_ROLLBACK_MODAL,
+            header: `${c19026_1.title} ${intl.formatToPlainString(GuildPowerups_messages["6e2ry1"], {
+              dateString: guildPowerupFormattedDateString
+            })}`,
+            bodies: [intl.formatToPlainString(GuildPowerups_messages.jd8fki, {
+              startDate: guildPowerupFormattedDateString,
+              endDate: guildPowerupFormattedDateString,
+              perkName: c19026_1.title,
+              boostCount: c19026_1.cost
+            })],
+            hasCancelButton: false
+          };
+        }
+      }
+      return null;
+    }, [shouldShow, r26, storeRemovalDate])
+  };
+};

modules/premium/powerups/hooks/useGuildPowerupRollbackNotificationConfig.tsx

@@ -0,0 +1,32 @@
+// Metro module 11589 (f11590).
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID } from "../../../../_bundle/Module4080";
+import { useShouldShowFileUploadRollback } from "../utils/fileUpload";
+import { DismissibleContent } from "../../../../_bundle/Module1358";
+import { intl } from "../../../../intl/index.native";
+import GuildPowerups_messages from "../GuildPowerups.messages";
+import getGuildPowerupFormattedDateString from "../utils/getGuildPowerupFormattedDateString";
+export default function useGuildPowerupRollbackNotificationConfig(a0, a1) {
+  const stateFromStores = useStateFromStores([GuildPowerupsStore], () => GuildPowerupsStore.getStateForGuild(a0));
+  const r18 = stateFromStores == null ? void 0 : stateFromStores.allPowerups[GUILD_POWERUP_MAX_FILE_SIZE_250_MB_SKU_ID];
+  const storeRemovalDate = r18?.storeRemovalDate;
+  const shouldShowFileUploadRollback = useShouldShowFileUploadRollback(a0, a1);
+  let r30 = null;
+  if (shouldShowFileUploadRollback) {
+    const r31 = storeRemovalDate != null;
+    r30 = r31 ? r18?.title != null ? r18?.cost != null ? {
+      dismissibleContent: DismissibleContent.FILE_UPLOAD_POWERUP_ROLLBACK_NOTIFICATION,
+      title: intl.formatToPlainString(GuildPowerups_messages["6e2ry1"], {
+        dateString: getGuildPowerupFormattedDateString(storeRemovalDate)
+      }),
+      description: intl.formatToPlainString(GuildPowerups_messages.jd8fki, {
+        startDate: getGuildPowerupFormattedDateString(storeRemovalDate),
+        endDate: getGuildPowerupFormattedDateString(storeRemovalDate),
+        perkName: r18?.title,
+        boostCount: r18?.cost
+      })
+    } : null : null : null;
+  }
+  return r30;
+};

modules/premium/powerups/hooks/useGuildPowerupTier3OverrideConfig.tsx

@@ -0,0 +1,18 @@
+// Metro module 11647 (f11648).
+import GuildStore from "../../../../stores/GuildStore";
+import { GuildFeatures } from "../../../../Constants";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { intl } from "../../../../intl/index.native";
+import GuildPowerups_messages from "../GuildPowerups.messages";
+export default function useGuildPowerupTier3OverrideConfig(c19050_0) {
+  return useStateFromStores([GuildStore], () => {
+    const guild = GuildStore.getGuild(c19050_0);
+    return (guild == null ? void 0 : guild.features.has(GuildFeatures.PREMIUM_TIER_3_OVERRIDE)) === true;
+  }) ? {
+    shouldShow: true,
+    text: intl.string(GuildPowerups_messages.l9n4QZ)
+  } : {
+    shouldShow: false,
+    text: ""
+  };
+};

modules/premium/powerups/hooks/useGuildPowerupsBoostCount.tsx

@@ -0,0 +1,74 @@
+// Metro module 4096 (f4097).
+import { useMemo } from "react";
+import GuildStore from "../../../../stores/GuildStore";
+import GameServerStore from "../../game_server/GameServerStore";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { useGameServerEnabled, getGameServerEnabled } from "../../game_server/GameServerExperiment";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+export default function useGuildAppliedBoostCount(a0) {
+  let total, gameServerEnabled, stateFromStores, stateFromStores2;
+  let r15 = useStateFromStores([GuildStore], () => GuildStore.getGuild(a0)?.premiumSubscriberCount);
+  if (r15 == null) {
+    r15 = 0;
+  }
+  total = r15;
+  gameServerEnabled = useGameServerEnabled(a0, "GuildPowerupsBoostCount");
+  stateFromStores = useStateFromStores([GuildPowerupsStore], () => GuildPowerupsStore.getStateForGuild(a0)?.appliedBoosts);
+  stateFromStores2 = useStateFromStores([GameServerStore], () => GameServerStore.getStateForGuild(a0)?.appliedBoosts);
+  return useMemo(() => {
+    L6: {
+      if (stateFromStores != null) {
+        if (gameServerEnabled && stateFromStores2 == null) {
+          break L6;
+        }
+        let r10 = stateFromStores2;
+        if (stateFromStores2 == null) {
+          r10 = 0;
+        }
+        const spent = stateFromStores + r10;
+        return {
+          available: Math.max(0, total - spent),
+          spent,
+          total,
+          isLoading: false
+        };
+      }
+    }
+    return {
+      available: 0,
+      spent: 0,
+      total,
+      isLoading: true
+    };
+  }, [total, stateFromStores, stateFromStores2, gameServerEnabled]);
+};
+export function getGuildPowerupsBoostCount(a0) {
+  let total2 = GuildStore.getGuild(a0)?.premiumSubscriberCount;
+  if (total2 == null) {
+    total2 = 0;
+  }
+  const gameServerEnabled2 = getGameServerEnabled(a0, "GuildPowerupsBoostCount");
+  const appliedBoosts = GuildPowerupsStore.getStateForGuild(a0)?.appliedBoosts;
+  let r26 = GameServerStore.getStateForGuild(a0)?.appliedBoosts;
+  L14: {
+    if (appliedBoosts != null) {
+      if (gameServerEnabled2 && r26 == null) {
+        break L14;
+      }
+      if (r26 == null) {
+        r26 = 0;
+      }
+      const spent = appliedBoosts + r26;
+      return {
+        available: Math.max(0, total2 - spent),
+        spent,
+        total: total2
+      };
+    }
+  }
+  return {
+    available: 0,
+    spent: 0,
+    total: total2
+  };
+}

modules/premium/powerups/hooks/useGuildPowerupsBoostLevelProgress.tsx

@@ -0,0 +1,27 @@
+// Metro module 4115 (f4116).
+import GuildStore from "../../../../stores/GuildStore";
+import { AppliedGuildBoostsRequiredForBoostedGuildTier, BoostedGuildTiers, GuildFeatures } from "../../../../Constants";
+import useGuildPowerupsBoostCount, { getGuildPowerupsBoostCount } from "./useGuildPowerupsBoostCount";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+export default function useGuildPowerupBoostLevelProgress(a0) {
+  const guildPowerupsBoostCount = useGuildPowerupsBoostCount(a0);
+  const stateFromStores = useStateFromStores([GuildStore], () => {
+    let r8 = GuildStore.getGuild(a0)?.premiumTier;
+    if (r8 == null) {
+      r8 = BoostedGuildTiers.NONE;
+    }
+    return r8;
+  });
+  return (useStateFromStores([GuildStore], () => {
+    const guild = GuildStore.getGuild(a0);
+    return (guild == null ? void 0 : guild.features.has(GuildFeatures.PREMIUM_TIER_3_OVERRIDE)) === true;
+  }) ? 0 : AppliedGuildBoostsRequiredForBoostedGuildTier[stateFromStores]) + guildPowerupsBoostCount.available;
+};
+export function getGuildPowerupBoostLevelProgress(a0) {
+  const guildPowerupsBoostCount = getGuildPowerupsBoostCount(a0);
+  let r14 = GuildStore.getGuild(a0)?.premiumTier;
+  if (r14 == null) {
+    r14 = BoostedGuildTiers.NONE;
+  }
+  return AppliedGuildBoostsRequiredForBoostedGuildTier[r14] + guildPowerupsBoostCount.available;
+}

modules/premium/powerups/hooks/useGuildPowerupsNewBadge.tsx

@@ -0,0 +1,63 @@
+// Metro module 11602 (f11603).
+import { useCallback, useEffect } from "react";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { GuildPowerupNewPerkMarketingVersion } from "../constants/GuildPowerupsConstants";
+import { ContentDismissActionType } from "../../../dismissible_content/DismissibleContentConstants";
+import { DismissibleContent } from "../../../../_bundle/Module1358";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import useGuildPowerupNewPerkMarketingVersion from "./useGuildPowerupNewPerkMarketingVersion";
+import { useSelectedVersionedDismissibleContent } from "../../../dismissible_content/hooks/useSelectedDismissibleContent";
+import { markVersionedDismissibleContentAsDismissed } from "../../../dismissible_content/DismissibleContentUtils";
+function $mk87713($env) {
+  return () => $env.$parent[5].getStateForGuild($env[0]);
+}
+let env7918 = {};
+const GUILD_POWERUP_NEW_PERK_AVAILABLE_BADGE = DismissibleContent.GUILD_POWERUP_NEW_PERK_AVAILABLE_BADGE;
+export default function useGuildPowerupsNewBadge(a0, r10 = false) {
+  let env19022;
+  const r8 = env19022 = {
+    $parent: env7918
+  };
+  env19022[0] = a0;
+  let r17 = useStateFromStores([GuildPowerupsStore], $mk87713(r8));
+  if (r17 == null) {
+    r17 = void 0;
+  }
+  const guildPowerupNewPerkMarketingVersion = useGuildPowerupNewPerkMarketingVersion(a0, r17);
+  const r24 = guildPowerupNewPerkMarketingVersion >= GuildPowerupNewPerkMarketingVersion.GUILD_THEME ? guildPowerupNewPerkMarketingVersion : 0;
+  const [r34, r35] = useSelectedVersionedDismissibleContent(r24 > 0 ? r10 ? null : GUILD_POWERUP_NEW_PERK_AVAILABLE_BADGE : null, r24);
+  let c19021_0 = r35;
+  const showNewBadgeOnRow = r34 === GUILD_POWERUP_NEW_PERK_AVAILABLE_BADGE;
+  let c19021_1 = showNewBadgeOnRow;
+  return {
+    showNewBadgeOnRow,
+    dismissNewBadgeIfShown: useCallback(function(r3 = ContentDismissActionType.TAKE_ACTION) {
+      if (c19021_1) {
+        c19021_0(r3);
+      }
+    }, [showNewBadgeOnRow, r35])
+  };
+};
+export function useAutoDismissGuildPowerupsNewBadge(a0) {
+  let env19024;
+  const guildId = a0;
+  const r4 = env19024 = {
+    $parent: env7918
+  };
+  env19024[0] = a0;
+  let r14 = useStateFromStores([GuildPowerupsStore], $mk87713(r4));
+  if (r14 == null) {
+    r14 = void 0;
+  }
+  const guildPowerupNewPerkMarketingVersion = useGuildPowerupNewPerkMarketingVersion(a0, r14);
+  const r22 = guildPowerupNewPerkMarketingVersion >= GuildPowerupNewPerkMarketingVersion.GUILD_THEME ? guildPowerupNewPerkMarketingVersion : 0;
+  let c19023_1 = r22;
+  useEffect(() => {
+    if (c19023_1 > 0) {
+      markVersionedDismissibleContentAsDismissed(GUILD_POWERUP_NEW_PERK_AVAILABLE_BADGE, c19023_1, {
+        dismissAction: ContentDismissActionType.AUTO_DISMISS,
+        guildId
+      });
+    }
+  }, [r22, a0]);
+}

modules/premium/powerups/hooks/useGuildPowerupsNotifications.tsx

@@ -0,0 +1,444 @@
+// Metro module 11583 (f11584).
+import { useMemo, useEffect } from "react";
+import GuildStore from "../../../../stores/GuildStore";
+import GameServerStore from "../../game_server/GameServerStore";
+import GuildPowerupsNotificationStore from "../GuildPowerupsNotificationStore";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { GUILD_POWERUP_NEW_PERK_GROUPS, POWERUPS_INCLUDED_IN_LEVEL, BOOSTING_TIER_TO_LEVEL_UNLOCKED_DC, BOOSTING_TIER_TO_LEVEL_SKU_ID, GuildPowerupNewPerkMarketingVersion, NEW_PERK_MARKETING_VERSION_TO_POWERUP_SKU_ID_SET } from "../constants/GuildPowerupsConstants";
+import { BoostedGuildTiers, GuildFeatures } from "../../../../Constants";
+import { ContentDismissActionType } from "../../../dismissible_content/DismissibleContentConstants";
+import { ReverseOrderedTiers } from "../../../../utils/GuildBoostingUtils";
+import * as _GuildDismissibleContentUtils from "../../../guild_dismissible_content/GuildDismissibleContentUtils";
+import { markContentAsDismissed } from "../../../guild_dismissible_content/GuildDismissibleContentUtils";
+import { GuildPowerupNotificationPopoutType, GuildPowerupNotificationIndicatorType } from "../constants/GuildPowerupsNotification";
+import { GUILD_POWERUP_GUILD_THEME_SKU_ID } from "../../../../_bundle/Module4080";
+import { isGuildPowerupRollbackEnabled } from "./useGuildPowerupRollbackEnabled";
+import { isNotNullish } from "../../../../utils/GlobalUtils";
+import { DismissibleGuildContent, DismissibleContent } from "../../../../_bundle/Module1358";
+import { getGameServerEnabled } from "../../game_server/GameServerExperiment";
+import useGuildPowerupsBoostCount from "./useGuildPowerupsBoostCount";
+import useGuildPowerupRollbackNotificationConfig from "./useGuildPowerupRollbackNotificationConfig";
+import { useIsSingleUseGuildDismissibleContentDismissed } from "../../../dismissible_content/DismissibleContentUtils";
+import { useStateFromStores } from "../../../../_bundle/defaultAreStatesEqual";
+import { getExpiringGuildEntitlements } from "../utils/getExpiringGuildEntitlements";
+import { usePerksCoachmarkDCF, useNewPerkAvailableCoachmarkDCF, useBoostToUnlockCoachmarkDCF, useExpiringPowerupCoachmarkDCF, useNewGamesCoachmarkDC, useGameServerPricingCoachmarkDCF, useGuildPowerupNotificationDCF } from "./GuildPowerupsNotificationsDCF.native";
+import { useServerThemeEnabled } from "../experiments/ServerThemeExperiment";
+import { useServerThemeUserEnabled } from "../experiments/ServerThemeUserExperiment";
+import useGuildPowerupNewPerkMarketingVersion from "./useGuildPowerupNewPerkMarketingVersion";
+import useBoostToUnlockFeaturedPowerup from "./useBoostToUnlockFeaturedPowerup";
+import useCanPurchaseBoosts from "./useCanPurchaseBoosts";
+import useFeaturedExpiringPowerup from "./useFeaturedExpiringPowerup";
+import { useIsNewGamesCoachmarkEnabled } from "../../game_server/experiments/NewGamesCoachmarkExperiment";
+import { useIsGameServerPricingEnabled } from "../../game_server/experiments/GameServerPricingExperiment";
+import { useAutoDismissGuildPowerupsNewBadge } from "./useGuildPowerupsNewBadge";
+import { guildPowerupsAckNotification } from "../GuildPowerupsActionCreators";
+import { HermesBuiltin } from "../../../../_hermes/prelude";
+function $mk87671($env) {
+  return (a0) => {
+    const r2 = $env.$parent;
+    const r5 = r2[9][a0];
+    const r6 = r5 != null ? $env[1].unlockedPowerups[r5] : void 0;
+    return r6 != null && r6.user_id !== r2[11];
+  };
+}
+function $mk87672($env) {
+  return (a0) => {
+    const r2 = $env;
+    const r3 = $env.$parent;
+    (0, r3[0])(r3[2][10]).markContentAsDismissed(r2[2], r2[0], true, a0);
+  };
+}
+function $mk87676($env) {
+  return (a0) => {
+    const r2 = $env.$parent;
+    const r3 = r2[0];
+    const r12 = r2[2];
+    r3(r12[10]).markContentAsDismissed(r3(r12[15]).DismissibleGuildContent.GAME_SERVER_HOSTING_GUILD_ELIGIBLE_COACHMARK, $env[0], true, a0);
+  };
+}
+function $mk87683($env) {
+  return () => $env.$parent[7].getNotificationStateForGuild($env[0]);
+}
+function $mk87684($env) {
+  return () => $env.$parent[8].getStateForGuild($env[0]);
+}
+let useGuildPowerupsNotificationIndicator, useGuildPowerupsChannelListPopout;
+let env7902 = {};
+export function maybeGetPerkPurchaseablePopoutDCF(a0, c19004_1, c19004_2, c19004_3) {
+  let c19004_0 = a0;
+  let r18 = GuildStore.getGuild(a0)?.premiumTier;
+  if (r18 == null) {
+    r18 = BoostedGuildTiers.NONE;
+  }
+  const NONE = r18;
+  const powerups = Array.from(GUILD_POWERUP_NEW_PERK_GROUPS.values()).flatMap((a0) => !(a0.length <= 0) && !a0.some((item) => {
+    if (c19004_1.unlockedPowerups[item] != null) {
+      return true;
+    }
+    const r9 = POWERUPS_INCLUDED_IN_LEVEL[item];
+    return r9 != null && NONE >= r9;
+  }) ? a0.map((item) => {
+    if (item === GUILD_POWERUP_GUILD_THEME_SKU_ID && !c19004_3) {
+      return null;
+    }
+    const r5 = c19004_1.allPowerups[item];
+    return r5 == null ? null : c19004_2 < r5.cost ? null : r5.dependencies.every((dependency) => c19004_1.unlockedPowerups[dependency] != null) ? isGuildPowerupRollbackEnabled(c19004_0, r5, "maybeGetPerkPurchaseablePopoutDCF") ? null : r5 : null;
+  }) : []).filter(isNotNullish);
+  if (powerups.length !== 0) {
+    return powerups.length === 1 && !_GuildDismissibleContentUtils.isContentDismissed(DismissibleGuildContent.GUILD_POWERUP_SINGLE_SKU_PURCHASE_COACHMARK, a0) ? {
+      type: GuildPowerupNotificationPopoutType.PERKS_PURCHASABLE,
+      powerups,
+      markAsDismissed: (a0) => {
+        markContentAsDismissed(DismissibleGuildContent.GUILD_POWERUP_SINGLE_SKU_PURCHASE_COACHMARK, c19004_0, true, a0);
+      }
+    } : powerups.length > 1 ? _GuildDismissibleContentUtils.isContentDismissed(DismissibleGuildContent.GUILD_POWERUP_CHOICE_SKU_PURCHASE_COACHMARK, a0) ? void 0 : {
+      type: GuildPowerupNotificationPopoutType.PERKS_PURCHASABLE,
+      powerups,
+      markAsDismissed: (a0) => {
+        markContentAsDismissed(DismissibleGuildContent.GUILD_POWERUP_CHOICE_SKU_PURCHASE_COACHMARK, c19004_0, true, a0);
+      }
+    } : void 0;
+  }
+}
+useGuildPowerupsNotificationIndicator = function useGuildPowerupsNotificationIndicator(a0, a1, a2) {
+  const available = useGuildPowerupsBoostCount(a0).available;
+  const guildPowerupRollbackNotificationConfig = useGuildPowerupRollbackNotificationConfig(a0, "useGuildPowerupsNotificationIndicator");
+  const isSingleUseGuildDismissibleContentDismissed = useIsSingleUseGuildDismissibleContentDismissed(guildPowerupRollbackNotificationConfig != null ? guildPowerupRollbackNotificationConfig.dismissibleContent : null, a0);
+  const r25 = guildPowerupRollbackNotificationConfig != null && !isSingleUseGuildDismissibleContentDismissed;
+  let c19006_4 = r25;
+  const stateFromStores = useStateFromStores([GameServerStore], () => GameServerStore.getStateForGuild(a0));
+  return useMemo(() => {
+    let r56;
+    if (a1 == null) {
+      return {
+        indicator: void 0,
+        showUnread: false
+      };
+    }
+    const r17 = Object.values(a1.unlockedPowerups);
+    const r23 = [];
+    const r0 = HermesBuiltin.arraySpread(r23, r17, 0);
+    const r14 = Object;
+    let r25 = stateFromStores?.entitlements;
+    if (r25 == null) {
+      r25 = {};
+    }
+    HermesBuiltin.arraySpread(r23, r14.values(r25), r0);
+    const expiringGuildEntitlements = getExpiringGuildEntitlements(r23);
+    let r33 = a2?.lastSeenWarningNotification;
+    if (r33 == null) {
+      r33 = Date.now();
+    }
+    const time = new Date(expiringGuildEntitlements[expiringGuildEntitlements.length - 1]?.ends_at).getTime();
+    let r50 = a2?.lastBoostCount;
+    if (r50 == null) {
+      r50 = 0;
+    }
+    const r52 = expiringGuildEntitlements.length > 0 && r33 < time;
+    L25: {
+      const count = available - r50;
+      if (!r52 && !c19006_4) {
+        if (available !== r50 && count > 0) {
+          r56 = {
+            indicator: {
+              type: GuildPowerupNotificationIndicatorType.UNREAD,
+              count
+            },
+            showUnread: true
+          };
+          break L25;
+        }
+        r56 = {
+          indicator: void 0,
+          showUnread: false
+        };
+      } else {
+        r56 = {
+          indicator: {
+            type: GuildPowerupNotificationIndicatorType.WARNING
+          },
+          showUnread: true
+        };
+      }
+    }
+    return r56;
+  }, [available, a2?.lastBoostCount, a2?.lastSeenWarningNotification, a1, r25, stateFromStores?.entitlements]);
+};
+useGuildPowerupsChannelListPopout = function useGuildPowerupsChannelListPopout(a0, a1) {
+  let stateFromStores3, serverThemeUserEnabled, c19007_8, c19007_10, powerup, c19007_13, featuredExpiringPowerup, c19007_16, c19007_18, c19007_20, memo, c19007_22, c19007_23;
+  let c19007_0 = a0;
+  const [r14, markAsDismissed2] = usePerksCoachmarkDCF(a1 != null);
+  const r4 = r14 === DismissibleContent.GUILD_POWERUP_PERKS_COACHMARK;
+  let c19007_3 = r4;
+  const available2 = useGuildPowerupsBoostCount(a0).available;
+  const stateFromStores2 = useStateFromStores([GuildStore], () => {
+    const guild = GuildStore.getGuild(c19007_0);
+    let r8 = guild == null ? void 0 : guild.features.has(GuildFeatures.GAME_SERVERS);
+    if (r8 == null) {
+      r8 = false;
+    }
+    return r8;
+  });
+  stateFromStores3 = useStateFromStores([GameServerStore], () => GameServerStore.getLowestGameCostForGuild(c19007_0));
+  let r22 = useServerThemeEnabled(a0, "useGuildPowerupsChannelListPopout");
+  const serverThemeUserEnabled2 = useServerThemeUserEnabled("useGuildPowerupsChannelListPopout");
+  if (r22) {
+    r22 = serverThemeUserEnabled2;
+  }
+  serverThemeUserEnabled = r22;
+  const guildPowerupNewPerkMarketingVersion = useGuildPowerupNewPerkMarketingVersion(a0, a1);
+  c19007_8 = guildPowerupNewPerkMarketingVersion;
+  let [r69, markAsDismissed3] = useNewPerkAvailableCoachmarkDCF(a1 != null && !r4, guildPowerupNewPerkMarketingVersion);
+  const r5 = r69 === DismissibleContent.GUILD_POWERUP_NEW_PERK_AVAILABLE_COACHMARK;
+  c19007_10 = r5;
+  powerup = useBoostToUnlockFeaturedPowerup(a0);
+  const canPurchaseBoosts = useCanPurchaseBoosts();
+  let [r85, markAsDismissed4] = useBoostToUnlockCoachmarkDCF(a1 != null && !r4 && !r5 && powerup != null && canPurchaseBoosts, a0);
+  const r6 = r85 === DismissibleContent.BOOST_TO_UNLOCK_COACHMARK;
+  c19007_13 = r6;
+  featuredExpiringPowerup = useFeaturedExpiringPowerup(a0);
+  let [r100, markAsDismissed5] = useExpiringPowerupCoachmarkDCF(a1 != null && !r4 && !r5 && !r6 && featuredExpiringPowerup != null, a0);
+  const r7 = r100 === DismissibleContent.EXPIRING_POWERUP_COACHMARK;
+  c19007_16 = r7;
+  const gameServerEnabled = getGameServerEnabled(a0, "useGuildPowerupsChannelListPopout");
+  const isNewGamesCoachmarkEnabled = useIsNewGamesCoachmarkEnabled("useGuildPowerupsChannelListPopout");
+  let [r117, markAsDismissed6] = useNewGamesCoachmarkDC(a1 != null && gameServerEnabled && isNewGamesCoachmarkEnabled);
+  const r8 = r117 === DismissibleContent.GAME_SERVER_NEW_GAMES_COACHMARK;
+  c19007_18 = r8;
+  const isGameServerPricingEnabled = useIsGameServerPricingEnabled(a0, "useGuildPowerupsChannelListPopout");
+  let [r133, markAsDismissed7] = useGameServerPricingCoachmarkDCF(a1 != null && !stateFromStores2 && gameServerEnabled && isGameServerPricingEnabled);
+  const r139 = r133 === DismissibleContent.GAME_SERVER_PRICING_CHANGE_COACHMARK;
+  c19007_20 = r139;
+  memo = useMemo(() => {
+    if (a1 != null && !c19007_3 && !c19007_10 && !c19007_18 && !c19007_20 && !c19007_13 && !c19007_16) {
+      let env27113;
+      const r6 = env7902;
+      const r7 = env27113 = {
+        $parent: r6
+      };
+      env27113[0] = c19007_0;
+      env27113[1] = a1;
+      const r28 = ReverseOrderedTiers.find($mk87671(r7));
+      const r2 = r28 != null;
+      let r29 = void 0;
+      if (r2) {
+        const r14 = BOOSTING_TIER_TO_LEVEL_UNLOCKED_DC[r28];
+        env27113[2] = r14;
+        const r31 = r14 != null;
+        r29 = void 0;
+        if (r31) {
+          const isContentDismissed = _GuildDismissibleContentUtils.isContentDismissed(r14, c19007_0);
+          r29 = void 0;
+          if (!isContentDismissed) {
+            const r36 = BOOSTING_TIER_TO_LEVEL_SKU_ID[r28];
+            const powerup2 = r36 != null ? a1.allPowerups[r36] : void 0;
+            r29 = powerup2 != null ? {
+              type: GuildPowerupNotificationPopoutType.LEVEL_REACHED,
+              powerup: powerup2,
+              markAsDismissed: $mk87672(r7)
+            } : void 0;
+          }
+        }
+      }
+      if (r29 != null) {
+        return r29;
+      }
+      const r49 = maybeGetPerkPurchaseablePopoutDCF(c19007_0, a1, available2, serverThemeUserEnabled);
+      if (r49 != null) {
+        return r49;
+      }
+      let env27114;
+      const r52 = env27114 = {
+        $parent: r6
+      };
+      env27114[0] = c19007_0;
+      const r58 = getGameServerEnabled(c19007_0, "maybeGetGameServerHostingGuildEligiblePopoutDCF") ? stateFromStores2 ? void 0 : stateFromStores3 != null ? available2 >= stateFromStores3 ? _GuildDismissibleContentUtils.isContentDismissed(DismissibleGuildContent.GAME_SERVER_HOSTING_GUILD_ELIGIBLE_COACHMARK, c19007_0) ? void 0 : {
+        type: GuildPowerupNotificationPopoutType.GAME_SERVER_HOSTING_GUILD_ELIGIBLE,
+        markAsDismissed: $mk87676(r52)
+      } : void 0 : void 0 : void 0;
+      return r58 ?? void 0;
+    }
+  }, [a0, a1, r4, r5, r8, r139, r6, r7, available2, stateFromStores2, stateFromStores3, serverThemeUserEnabled]);
+  const [r151, r152] = useGuildPowerupNotificationDCF(memo != null);
+  c19007_22 = r151;
+  c19007_23 = r152;
+  return useMemo(() => {
+    if (a1 != null) {
+      if (c19007_3) {
+        return {
+          type: GuildPowerupNotificationPopoutType.PERKS_AVAILABLE,
+          markAsDismissed: markAsDismissed2
+        };
+      }
+      if (c19007_10) {
+        if (c19007_8 === GuildPowerupNewPerkMarketingVersion.GAME_SERVER_HOSTING) {
+          return {
+            type: GuildPowerupNotificationPopoutType.GAME_SERVER_HOSTING_AVAILABLE,
+            markAsDismissed: markAsDismissed3
+          };
+        }
+        let c27115_0 = NEW_PERK_MARKETING_VERSION_TO_POWERUP_SKU_ID_SET[c19007_8];
+        const powerups = Object.values(a1.allPowerups).filter((item) => c27115_0.has(item.skuId));
+        if (powerups.length === 0) {
+          return void 0;
+        }
+        return {
+          powerups,
+          type: GuildPowerupNotificationPopoutType.NEW_PERK_AVAILABLE,
+          markAsDismissed: markAsDismissed3
+        };
+      }
+      return c19007_13 && powerup != null ? {
+        type: GuildPowerupNotificationPopoutType.BOOST_TO_UNLOCK,
+        powerup,
+        markAsDismissed: markAsDismissed4
+      } : c19007_16 && featuredExpiringPowerup != null ? {
+        type: GuildPowerupNotificationPopoutType.EXPIRING_PERK,
+        featuredExpiringPowerup,
+        markAsDismissed: markAsDismissed5
+      } : c19007_18 ? {
+        type: GuildPowerupNotificationPopoutType.GAME_SERVER_NEW_GAMES,
+        markAsDismissed: markAsDismissed6
+      } : c19007_20 ? {
+        type: GuildPowerupNotificationPopoutType.GAME_SERVER_PRICING_CHANGE,
+        markAsDismissed: markAsDismissed7
+      } : c19007_22 === DismissibleContent.GUILD_POWERUP_NOTIFICATION ? memo != null ? {
+        ...memo,
+        markAsDismissed: (a0) => {
+          c19007_23(a0);
+          memo.markAsDismissed(a0);
+        }
+      } : void 0 : void 0;
+    }
+  }, [a1, r4, markAsDismissed2, memo, r151, r152, r5, markAsDismissed3, guildPowerupNewPerkMarketingVersion, r6, powerup, markAsDismissed4, r7, featuredExpiringPowerup, markAsDismissed5, r8, markAsDismissed6, r139, markAsDismissed7]);
+};
+export default function useGuildPowerupsNotifications(a0) {
+  let env19008;
+  const r2 = env19008 = {
+    $parent: env7902
+  };
+  env19008[0] = a0;
+  const stateFromStores5 = useStateFromStores([GuildPowerupsNotificationStore], $mk87683(r2), [a0]);
+  const stateFromStores6 = useStateFromStores([GuildPowerupsStore], $mk87684(r2));
+  const guildPowerupsNotificationIndicator = useGuildPowerupsNotificationIndicator(a0, stateFromStores6 == null ? void 0 : stateFromStores6, stateFromStores5);
+  const { indicator, showUnread } = guildPowerupsNotificationIndicator;
+  let r28 = stateFromStores6;
+  if (r28 == null) {
+    r28 = void 0;
+  }
+  L8: {
+    const popout = useGuildPowerupsChannelListPopout(a0, r28);
+    if (stateFromStores6 !== null) {
+      if (indicator == null && !showUnread && popout == null) {
+        break L8;
+      }
+      return {
+        indicator,
+        showUnread,
+        popout
+      };
+    }
+  }
+};
+export function maybeGetLevelUnlockedPopoutDCF(a0, a1) {
+  let env19003;
+  const r4 = env19003 = {
+    $parent: env7902
+  };
+  env19003[0] = a0;
+  env19003[1] = a1;
+  const r15 = ReverseOrderedTiers.find($mk87671(r4));
+  if (r15 != null) {
+    const r11 = BOOSTING_TIER_TO_LEVEL_UNLOCKED_DC[r15];
+    env19003[2] = r11;
+    if (r11 != null && !_GuildDismissibleContentUtils.isContentDismissed(r11, a0)) {
+      const r22 = BOOSTING_TIER_TO_LEVEL_SKU_ID[r15];
+      const powerup2 = r22 != null ? a1.allPowerups[r22] : void 0;
+      if (powerup2 != null) {
+        return {
+          type: GuildPowerupNotificationPopoutType.LEVEL_REACHED,
+          powerup: powerup2,
+          markAsDismissed: $mk87672(r4)
+        };
+      }
+    }
+  }
+}
+export function maybeGetGameServerHostingGuildEligiblePopoutDCF(a0, a1, a2, a3) {
+  let env19005;
+  const r3 = env19005 = {
+    $parent: env7902
+  };
+  env19005[0] = a0;
+  if (getGameServerEnabled(a0, "maybeGetGameServerHostingGuildEligiblePopoutDCF") && !a1 && a3 != null && a2 >= a3 && !_GuildDismissibleContentUtils.isContentDismissed(DismissibleGuildContent.GAME_SERVER_HOSTING_GUILD_ELIGIBLE_COACHMARK, a0)) {
+    return {
+      type: GuildPowerupNotificationPopoutType.GAME_SERVER_HOSTING_GUILD_ELIGIBLE,
+      markAsDismissed: $mk87676(r3)
+    };
+  }
+}
+export { useGuildPowerupsNotificationIndicator };
+export { useGuildPowerupsChannelListPopout };
+export function useAutoDismissGuildPowerupsNotifications(a0) {
+  let r37;
+  let c19009_2;
+  let env19010;
+  const stateFromStores4 = useStateFromStores([GuildPowerupsStore], () => GuildPowerupsStore.getStateForGuild(a0));
+  const r17 = env19010 = {
+    $parent: env7902
+  };
+  env19010[0] = a0;
+  const stateFromStores5 = useStateFromStores([GuildPowerupsNotificationStore], $mk87683(r17), [a0]);
+  const stateFromStores6 = useStateFromStores([GuildPowerupsStore], $mk87684(r17));
+  const guildPowerupsNotificationIndicator = useGuildPowerupsNotificationIndicator(a0, stateFromStores6 == null ? void 0 : stateFromStores6, stateFromStores5);
+  const { indicator, showUnread } = guildPowerupsNotificationIndicator;
+  let r35 = stateFromStores6;
+  if (r35 == null) {
+    r35 = void 0;
+  }
+  L9: {
+    const popout = useGuildPowerupsChannelListPopout(a0, r35);
+    r37 = void 0;
+    if (stateFromStores6 !== null) {
+      if (indicator == null && !showUnread) {
+        const r38 = popout != null;
+        r37 = void 0;
+        if (!r38) {
+          break L9;
+        }
+      }
+      r37 = {
+        indicator,
+        showUnread,
+        popout
+      };
+    }
+  }
+  c19009_2 = r37;
+  useAutoDismissGuildPowerupsNewBadge(a0);
+  useEffect(() => {
+    guildPowerupsAckNotification(a0);
+  }, [a0]);
+  useEffect(() => {
+    const set = new Set([GuildPowerupNotificationPopoutType.BOOST_TO_UNLOCK, GuildPowerupNotificationPopoutType.EXPIRING_PERK]);
+    if (!((c19009_2 == null ? void 0 : c19009_2.popout?.type) != null && set.has(c19009_2.popout.type)) && c19009_2 != null) {
+      const popout = c19009_2.popout;
+      if (popout != null) {
+        popout.markAsDismissed(ContentDismissActionType.AUTO_DISMISS);
+      }
+    }
+  }, [r37]);
+  useEffect(() => {
+    if (stateFromStores4 != null) {
+      ReverseOrderedTiers.forEach((reverseOrderedTier) => {
+        const r5 = BOOSTING_TIER_TO_LEVEL_SKU_ID[reverseOrderedTier];
+        if (r5 != null && stateFromStores4.unlockedPowerups[r5] != null) {
+          const r15 = BOOSTING_TIER_TO_LEVEL_UNLOCKED_DC[reverseOrderedTier];
+          if (r15 != null) {
+            markContentAsDismissed(r15, a0, false, ContentDismissActionType.AUTO_DISMISS);
+          }
+        }
+      });
+    }
+  }, [a0, stateFromStores4]);
+}

modules/premium/powerups/hooks/useGuildPowerupsWarningConfig.tsx

@@ -0,0 +1,42 @@
+// Metro module 11652 (f11653).
+import { useMemo } from "react";
+import AppliedGuildBoostStore from "../../../../stores/AppliedGuildBoostStore";
+import useGuildPowerupsBoostCount from "./useGuildPowerupsBoostCount";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { intl } from "../../../../intl/index.native";
+import GuildPowerups_messages from "../GuildPowerups.messages";
+export default function useGuildPowerupsWarningConfig(a0, a1) {
+  let boostCount;
+  let c19054_0 = a0;
+  const spent = useGuildPowerupsBoostCount(a0).spent;
+  const stateFromStores = useStateFromStores([AppliedGuildBoostStore], () => AppliedGuildBoostStore.getAppliedGuildBoostsForGuild(c19054_0), [a0]);
+  boostCount = spent - useMemo(() => {
+    const r3 = stateFromStores == null;
+    let r8 = void 0;
+    if (!r3) {
+      const filter = stateFromStores.filter;
+      r8 = filter == null ? void 0 : filter.call(stateFromStores, (a0) => {
+        const ended = a0.ended;
+        return ended ? !ended : a0.endsAt == null;
+      })?.length;
+    }
+    if (r8 == null) {
+      r8 = 0;
+    }
+    return r8;
+  }, [stateFromStores]);
+  return useMemo(() => boostCount <= 0 ? {
+    shouldShow: false,
+    title: "",
+    description: "",
+    requiredBoostCount: 0
+  } : {
+    shouldShow: true,
+    title: intl.string(GuildPowerups_messages.n5hQhc),
+    description: intl.formatToPlainString(GuildPowerups_messages.iAaAiG, {
+      boostCount,
+      perksString: a1.join(", ")
+    }),
+    requiredBoostCount: boostCount
+  }, [boostCount, a1]);
+};

modules/premium/powerups/hooks/useHasAllocateBoostPermission.tsx

@@ -0,0 +1,14 @@
+// Metro module 11605 (f11606).
+import GuildStore from "../../../../stores/GuildStore";
+import PermissionStore from "../../../../stores/PermissionStore";
+import { Permissions } from "../../../../_bundle/Module505";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+export default function useHasAllocateBoostPermission(c19027_0) {
+  return useStateFromStores([PermissionStore, GuildStore], () => {
+    const guild = GuildStore.getGuild(c19027_0);
+    return guild == null ? null : PermissionStore.getGuildPermissions(guild) == null ? null : PermissionStore.can(Permissions.ADMINISTRATOR, guild);
+  });
+};
+export function getHasAllocateBoostPermission(a0, a1) {
+  return a1 == null ? null : a0.getGuildPermissions(a1) == null ? null : a0.can(Permissions.ADMINISTRATOR, a1);
+}

modules/premium/powerups/hooks/useHasEnhancedRoleColors.tsx

@@ -0,0 +1,27 @@
+// Metro module 4628 (f4629).
+import GuildStore from "../../../../stores/GuildStore";
+import { GuildFeatures } from "../../../../Constants";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+export default function useHasEnhancedRoleColors(c14368_0) {
+  return useStateFromStores([GuildStore], () => {
+    const guild = GuildStore.getGuild(c14368_0);
+    return guild != null && guild.features.has(GuildFeatures.ENHANCED_ROLE_COLORS);
+  });
+};
+export function getHasEnhancedRoleColors(a0) {
+  if (a0 == null) {
+    return false;
+  }
+  const guild = GuildStore.getGuild(a0);
+  return guild != null && guild.features.has(GuildFeatures.ENHANCED_ROLE_COLORS);
+}
+export function useHasEnhancedRoleColorsForRole(c14369_0) {
+  return useStateFromStores([GuildStore], () => {
+    const guild = GuildStore.getGuild(c14369_0);
+    return guild != null && guild.features.has(GuildFeatures.ENHANCED_ROLE_COLORS);
+  });
+}
+export function getHasEnhancedRoleColorsForRole(a0) {
+  const guild = GuildStore.getGuild(a0);
+  return guild != null && guild.features.has(GuildFeatures.ENHANCED_ROLE_COLORS);
+}

modules/premium/powerups/hooks/useIsCurrentUserEligibleForPowerupUpsells.tsx

@@ -0,0 +1,47 @@
+// Metro module 15140 (f15141).
+import "../../../../stores/GuildMemberStore";
+import SortedGuildStore from "../../../../stores/SortedGuildStore";
+import UserStore from "../../../../stores/UserStore";
+import GuildBoostSlotStore from "../../../../stores/billing/GuildBoostSlotStore";
+import { PremiumTypes } from "../../PremiumConstants";
+import { isPremium } from "../../../../utils/PremiumTypeUtils";
+import { useStateFromStores, useStateFromStoresArray } from "../../../../_bundle/Module589";
+function $mk95545() {
+  return (a0) => a0.premiumGuildSubscription != null;
+}
+function $mk95546($env) {
+  return (a0) => $env.$parent[2].getMember(a0, $env[0].id)?.premiumSince != null;
+}
+let env10741 = {};
+export default function useIsCurrentUserEligibleForPowerupUpsells() {
+  let env21702;
+  const stateFromStores = useStateFromStores([UserStore], () => UserStore.getCurrentUser());
+  const stateFromStoresArray = useStateFromStoresArray([GuildBoostSlotStore], () => GuildBoostSlotStore.hasFetched ? Object.values(GuildBoostSlotStore.boostSlots) : []);
+  const stateFromStores2 = useStateFromStores([SortedGuildStore], () => SortedGuildStore.getFlattenedGuildIds());
+  const r27 = env21702 = {
+    $parent: env10741
+  };
+  env21702[0] = stateFromStores;
+  let r28 = stateFromStores != null;
+  if (r28) {
+    const isPremiumGroupMember = stateFromStores.isPremiumGroupMember();
+    r28 = isPremiumGroupMember ? !isPremiumGroupMember : !!isPremium(stateFromStores, PremiumTypes.TIER_2) || (!!stateFromStoresArray.some($mk95545()) || stateFromStores2.some($mk95546(r27)));
+  }
+  return r28;
+};
+export function getIsCurrentUserEligibleForPowerupUpsells() {
+  const currentUser = UserStore.getCurrentUser();
+  const r9 = GuildBoostSlotStore.hasFetched ? Object.values(GuildBoostSlotStore.boostSlots) : [];
+  let env21703;
+  const flattenedGuildIds = SortedGuildStore.getFlattenedGuildIds();
+  const r6 = env21703 = {
+    $parent: env10741
+  };
+  env21703[0] = currentUser;
+  let r18 = currentUser != null;
+  if (r18) {
+    const isPremiumGroupMember = currentUser.isPremiumGroupMember();
+    r18 = isPremiumGroupMember ? !isPremiumGroupMember : !!isPremium(currentUser, PremiumTypes.TIER_2) || (!!r9.some($mk95545()) || flattenedGuildIds.some($mk95546(r6)));
+  }
+  return r18;
+}

modules/premium/powerups/hooks/useIsGuildThemePerkEnabled.tsx

@@ -0,0 +1,27 @@
+// Metro module 15132 (f15133).
+import GuildStore from "../../../../stores/GuildStore";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import { GuildFeatures } from "../../../../Constants";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import { GUILD_POWERUP_GUILD_THEME_SKU_ID } from "../../../../_bundle/Module4080";
+export default function useIsGuildThemePerkEnabled(a0) {
+  return useStateFromStores([GuildStore, GuildPowerupsStore], () => {
+    let r1 = a0 != null;
+    if (r1) {
+      const guild = GuildStore.getGuild(a0);
+      let r17 = (guild == null ? void 0 : guild.features.has(GuildFeatures.GUILD_THEME)) === true;
+      if (!r17) {
+        const stateForGuild = GuildPowerupsStore.getStateForGuild(a0);
+        const r4 = stateForGuild == null;
+        let r21 = void 0;
+        if (!r4) {
+          const unlockedPowerups = stateForGuild.unlockedPowerups;
+          r21 = unlockedPowerups == null ? void 0 : unlockedPowerups[GUILD_POWERUP_GUILD_THEME_SKU_ID];
+        }
+        r17 = r21 != null;
+      }
+      r1 = r17;
+    }
+    return r1;
+  }, [a0]);
+};

modules/premium/powerups/hooks/useIsServerThemeAvailableForGuild.tsx

@@ -0,0 +1,7 @@
+// Metro module 13049 (f13050).
+import { useServerThemeEnabled } from "../experiments/ServerThemeExperiment";
+import { useEnabledGuildThemeForGuildId } from "../../../guild_themes/GuildThemeResolver";
+export default function useIsServerThemeAvailableForGuild(a0, a1) {
+  useServerThemeEnabled(a0 == null ? void 0 : a0, a1);
+  return useEnabledGuildThemeForGuildId(a0, a1) != null;
+};

modules/premium/powerups/hooks/useLoadGuildPowerups.tsx

@@ -0,0 +1,17 @@
+// Metro module 11573 (f11574).
+import { useEffect } from "react";
+import { useGameServerEnabled } from "../../game_server/GameServerExperiment";
+import { fetchGameServerCatalog } from "../../game_server/GameServerActionCreators";
+import { fetchPowerupCatalogForGuild, fetchGuildBoostEntitlements } from "../GuildPowerupsActionCreators";
+export default function useLoadGuildPowerups(a0) {
+  const gameServerEnabled = useGameServerEnabled(a0, "useLoadGuildPowerups");
+  useEffect(() => {
+    if (gameServerEnabled) {
+      fetchGameServerCatalog(a0);
+    }
+  }, [a0, gameServerEnabled]);
+  useEffect(() => {
+    fetchPowerupCatalogForGuild(a0);
+    fetchGuildBoostEntitlements(a0);
+  }, [a0]);
+};

modules/premium/powerups/hooks/useMarketablePowerupPerks.tsx

@@ -0,0 +1,36 @@
+// Metro module 12640 (f12641).
+import { useMemo } from "react";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import * as _GuildPowerupsConstants from "../constants/GuildPowerupsConstants";
+import { GuildPowerupType } from "../constants/GuildPowerupsConstants";
+import { VANITY_URL_POWERUP_SKU_ID } from "../../../../_bundle/Module4080";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+import useGameServerPerk from "../../game_server/hooks/useGameServerPerk";
+const { GUILD_TAG_BADGE_PACKS_WAVE_ONE_SKU_ID_SET, GUILD_TAG_BADGE_PACKS_WAVE_TWO_SKU_ID_SET } = _GuildPowerupsConstants;
+let c8725_6 = new Set([...Array.from(GUILD_TAG_BADGE_PACKS_WAVE_ONE_SKU_ID_SET), ...Array.from(GUILD_TAG_BADGE_PACKS_WAVE_TWO_SKU_ID_SET), VANITY_URL_POWERUP_SKU_ID]);
+export default function useMarketablePowerupPerks(a0) {
+  let c19951_2;
+  const stateFromStores = useStateFromStores([GuildPowerupsStore], () => {
+    const stateForGuild = GuildPowerupsStore.getStateForGuild(a0);
+    const r2 = stateForGuild == null;
+    let r9 = void 0;
+    if (!r2) {
+      const powerupCatalog = stateForGuild.powerupCatalog;
+      r9 = powerupCatalog == null ? void 0 : powerupCatalog[GuildPowerupType.PERK];
+    }
+    return r9;
+  });
+  const gameServerPerk = useGameServerPerk(a0);
+  c19951_2 = gameServerPerk;
+  return useMemo(() => {
+    let r3 = stateFromStores;
+    if (stateFromStores == null) {
+      r3 = [];
+    }
+    const r4 = [...r3];
+    if (c19951_2 != null) {
+      r4.push(c19951_2);
+    }
+    return r4.filter((item) => !c8725_6.has(item.skuId));
+  }, [stateFromStores, gameServerPerk]);
+};

modules/premium/powerups/hooks/useMaybeGetSortedBoosts.tsx

@@ -0,0 +1,107 @@
+// Metro module 11671 (f11672).
+import _slicedToArray from "../../../../_bundle/_slicedToArray";
+import { useState, useMemo, useEffect } from "react";
+import AppliedGuildBoostStore from "../../../../stores/AppliedGuildBoostStore";
+import GuildMemberRequesterStore from "../../../../stores/GuildMemberRequesterStore";
+import GuildMemberStore from "../../../../stores/GuildMemberStore";
+import GuildStore from "../../../../stores/GuildStore";
+import { useExpiringBoostsEnabled } from "../experiments/ExpiringBoostsExperiment";
+import { useStateFromStoresArray, useStateFromStores, useStateFromStoresObject } from "../../../../_bundle/Module589";
+import { getBoostLifecycleInfo, getBoostLifecycleTimestamp } from "../utils/getBoostLifecyclePhase";
+import { fetchAppliedGuildBoostsForGuild } from "../../../../actions/BoostingActionCreators";
+import SnowflakeUtils from "../../../../utils/SnowflakeUtils";
+import { intl, t } from "../../../../intl/index.native";
+export default function useMaybeGetSortedBoosts(a0, a1) {
+  let state, memo, stateFromStoresArray2, stateFromStores, memo2, stateFromStores2;
+  const expiringBoostsEnabled = useExpiringBoostsEnabled("GuildPowerupsRecentActivity");
+  const stateFromStoresArray = useStateFromStoresArray([AppliedGuildBoostStore], () => {
+    let r6 = AppliedGuildBoostStore.getAppliedGuildBoostsForGuild(a0);
+    if (r6 == null) {
+      r6 = [];
+    }
+    return r6;
+  }, [a0]);
+  state = _slicedToArray(useState(() => Date.now()), 1)[0];
+  memo = useMemo(() => stateFromStoresArray.map((item) => {
+    const r3 = expiringBoostsEnabled ? getBoostLifecycleInfo(item, state) : {
+      phase: "gave"
+    };
+    const boostLifecycleTimestamp = getBoostLifecycleTimestamp(item, r3);
+    return r3.phase === "expiring" ? {
+      boost: item,
+      phase: "expiring",
+      sortKey: boostLifecycleTimestamp,
+      endsAt: r3.endsAt
+    } : {
+      boost: item,
+      phase: r3.phase,
+      sortKey: boostLifecycleTimestamp
+    };
+  }).sort((a, b) => b.sortKey - a.sortKey).slice(0, a1), [stateFromStoresArray, a1, state, expiringBoostsEnabled]);
+  stateFromStoresArray2 = useStateFromStoresArray([GuildMemberStore], () => {
+    const set = new Set();
+    let c27125_0 = set;
+    memo.forEach(({ boost }) => {
+      if (GuildMemberStore.getMember(a0, boost.userId) == null) {
+        c27125_0.add(boost.userId);
+      }
+    });
+    return Array.from(set);
+  }, [a0, memo]);
+  useEffect(() => {
+    if (stateFromStoresArray2.length > 0) {
+      stateFromStoresArray2.forEach((item) => GuildMemberRequesterStore.requestMember(a0, item));
+    }
+  }, [a0, stateFromStoresArray2]);
+  stateFromStores = useStateFromStores([GuildStore], () => GuildStore.getGuild(a0)?.premiumSubscriberCount);
+  memo2 = useMemo(() => stateFromStoresArray.filter((item) => !item.ended).length, [stateFromStoresArray]);
+  stateFromStores2 = useStateFromStores([AppliedGuildBoostStore], () => AppliedGuildBoostStore.getLastFetchedAtForGuild(a0) != null, [a0]);
+  useEffect(() => {
+    let r6 = stateFromStores !== memo2;
+    if (!r6) {
+      let r7 = expiringBoostsEnabled;
+      if (expiringBoostsEnabled) {
+        r7 = !stateFromStores2;
+      }
+      r6 = r7;
+    }
+    if (r6) {
+      fetchAppliedGuildBoostsForGuild(a0, {
+        includeEnded: expiringBoostsEnabled
+      });
+    }
+  }, [a0, stateFromStores, memo2, expiringBoostsEnabled, stateFromStores2]);
+  return memo;
+};
+export function useGetBoostUserConfig(a0) {
+  const date = new Date(SnowflakeUtils.extractTimestamp(a0.id));
+  const stateFromStoresObject = useStateFromStoresObject([GuildMemberStore], () => {
+    const member = GuildMemberStore.getMember(a0.guildId, a0.userId);
+    let username = GuildMemberStore.getNick(a0.guildId, a0.userId);
+    if (username == null) {
+      username = a0.user?.username;
+    }
+    if (username == null) {
+      username = intl.string(t["30mdIx"]);
+    }
+    let roleColor = member?.colorString;
+    if (roleColor == null) {
+      roleColor = null;
+    }
+    let roleColorStrings = member?.colorStrings;
+    if (roleColorStrings == null) {
+      roleColorStrings = null;
+    }
+    return {
+      username,
+      roleColor,
+      roleColorStrings
+    };
+  }, [a0]);
+  return {
+    timestamp: date,
+    username: stateFromStoresObject.username,
+    roleColor: stateFromStoresObject.roleColor,
+    roleColorStrings: stateFromStoresObject.roleColorStrings
+  };
+}

modules/premium/powerups/hooks/useMultiPerkStatusValues.tsx

@@ -0,0 +1,62 @@
+// Metro module 11664 (f11665).
+import { PowerupActiveStatusType } from "../constants/GuildPowerupsConstants";
+import { usePowerupsActiveStatuses } from "./usePowerupActiveStatus";
+import { intl } from "../../../../intl/index.native";
+import GuildPowerups_messages from "../GuildPowerups.messages";
+export default function useMultiPerkStatusValues({ guildId, powerups }) {
+  const powerupsActiveStatuses = usePowerupsActiveStatuses(guildId, powerups);
+  const isActive = powerupsActiveStatuses.some((powerupsActiveStatuse) => powerupsActiveStatuse.type !== PowerupActiveStatusType.INACTIVE);
+  if (powerups.length <= 0) {
+    return null;
+  }
+  const expiringAt = powerupsActiveStatuses.reduce((acc, powerupsActiveStatuse) => {
+    const ends_at = powerupsActiveStatuse.sourceEntitlement?.ends_at;
+    return ends_at != null ? acc != null ? ends_at < acc ? ends_at : acc : ends_at : acc;
+  }, void 0);
+  const status = expiringAt != null ? {
+    type: "expiring",
+    expiringAt
+  } : isActive ? {
+    type: "active",
+    statusText: intl.string(GuildPowerups_messages.FFLkmx)
+  } : void 0;
+  const activeCost = powerupsActiveStatuses.reduce((acc, { type, powerup }) => type === PowerupActiveStatusType.POWERUP_ACTIVATED ? acc + powerup.cost : acc, 0);
+  const r37 = powerupsActiveStatuses[0];
+  let r38 = r37 == null ? void 0 : r37.powerup?.cost;
+  if (r38 == null) {
+    r38 = 0;
+  }
+  const minCost = powerupsActiveStatuses.reduce((acc, { powerup }) => {
+    let r6 = powerup?.cost;
+    if (r6 == null) {
+      r6 = 0;
+    }
+    let r7 = acc;
+    if (!(acc < r6)) {
+      let r4 = powerup?.cost;
+      if (r4 == null) {
+        r4 = 0;
+      }
+      r7 = r4;
+    }
+    return r7;
+  }, r38);
+  const totalCost = powerupsActiveStatuses.reduce((acc, powerupsActiveStatuse) => {
+    let r4 = powerupsActiveStatuse.powerup?.cost;
+    if (r4 == null) {
+      r4 = 0;
+    }
+    return acc + r4;
+  }, 0);
+  const cost = isActive ? activeCost : minCost;
+  return {
+    isActive,
+    status,
+    cost,
+    costDecorator: isActive ? void 0 : totalCost > cost ? "+" : void 0,
+    expiringAt,
+    activeCost,
+    minCost,
+    totalCost
+  };
+};

modules/premium/powerups/hooks/usePowerupActiveStatus.tsx

@@ -0,0 +1,175 @@
+// Metro module 11591 (f11592).
+import GuildStore from "../../../../stores/GuildStore";
+import GuildPowerupsStore from "../GuildPowerupsStore";
+import "../../game_server/GameServerConstants";
+import { PowerupActiveStatusType } from "../constants/GuildPowerupsConstants";
+import { GuildFeatures } from "../../../../Constants";
+import { useStateFromStores } from "../../../../_bundle/Module589";
+function $mk87696($env) {
+  return () => $env.$parent[2].getGuild($env[0]);
+}
+function $mk87697($env) {
+  return () => $env.$parent[3].getStateForGuild($env[0]);
+}
+function $mk87698($env) {
+  return (a0) => {
+    let r27, r41;
+    const r6 = $env;
+    const skuId = a0.skuId;
+    const r4 = $env.$parent;
+    if (skuId === r4[4]) {
+      const r48 = r6[1];
+      const r50 = r48 == null;
+      let r51 = void 0;
+      if (!r50) {
+        const features = r48.features;
+        r51 = features == null ? void 0 : features.has(r4[9].GAME_SERVERS);
+      }
+      r41 = {
+        type: r51 != null && r51 ? r4[6].POWERUP_ACTIVATED : r4[6].INACTIVE,
+        powerup: a0,
+        sourceEntitlement: void 0,
+        sourcePowerup: void 0
+      };
+    } else {
+      L16: {
+        if (a0 != null) {
+          const r14 = r6[1];
+          if (r14 != null) {
+            const r9 = r6[2];
+            if (r9 != null) {
+              const r16 = r4[7][a0.skuId];
+              if (r16 == null) {
+                r27 = {
+                  isActiveFromLevel: false,
+                  levelEntitlement: void 0,
+                  levelPowerup: void 0
+                };
+                break L16;
+              }
+              const isActiveFromLevel2 = r14.premiumTier >= r16;
+              const r10 = r4[8][r16];
+              const r1 = r10 != null;
+              let levelEntitlement2 = void 0;
+              if (r1) {
+                const unlockedPowerups = r9.unlockedPowerups;
+                levelEntitlement2 = unlockedPowerups == null ? void 0 : unlockedPowerups[r10];
+              }
+              const r22 = r10 != null;
+              let levelPowerup2 = void 0;
+              if (r22) {
+                const allPowerups = r9.allPowerups;
+                levelPowerup2 = allPowerups == null ? void 0 : allPowerups[r10];
+              }
+              r27 = {
+                isActiveFromLevel: isActiveFromLevel2,
+                levelEntitlement: levelEntitlement2,
+                levelPowerup: levelPowerup2
+              };
+              break L16;
+            }
+          }
+        }
+        r27 = {
+          isActiveFromLevel: false,
+          levelEntitlement: void 0,
+          levelPowerup: void 0
+        };
+      }
+      const { isActiveFromLevel, levelEntitlement, levelPowerup } = r27;
+      const r30 = r6[3] && r4[5].has(a0.skuId);
+      const r34 = r6[2];
+      const r35 = r34 == null;
+      let sourceEntitlement = void 0;
+      if (!r35) {
+        const unlockedPowerups2 = r34.unlockedPowerups;
+        sourceEntitlement = unlockedPowerups2 == null ? void 0 : unlockedPowerups2[a0.skuId];
+      }
+      if (sourceEntitlement == null) {
+        sourceEntitlement = null;
+      }
+      const r40 = r4[6];
+      r41 = {
+        type: r40.INACTIVE,
+        powerup: a0,
+        sourceEntitlement: void 0,
+        sourcePowerup: void 0
+      };
+      if (isActiveFromLevel) {
+        r41 = {
+          type: r40.LEVEL_ACTIVATED,
+          powerup: a0,
+          sourceEntitlement: levelEntitlement,
+          sourcePowerup: levelPowerup
+        };
+      } else if (r30) {
+        r41 = {
+          type: r40.TIER_OVERRIDE_ACTIVATED,
+          powerup: a0,
+          sourceEntitlement: void 0,
+          sourcePowerup: a0
+        };
+      } else if (sourceEntitlement != null) {
+        r41 = {
+          type: r40.POWERUP_ACTIVATED,
+          powerup: a0,
+          sourceEntitlement,
+          sourcePowerup: a0
+        };
+      }
+    }
+    return r41;
+  };
+}
+let env7908 = {};
+export default function usePowerupActiveStatus(a0, a1) {
+  const r7 = a1 == null ? [] : [a1];
+  let env19017;
+  const r13 = env19017 = {
+    $parent: env7908
+  };
+  env19017[0] = a0;
+  const stateFromStores = useStateFromStores([GuildStore], $mk87696(r13));
+  env19017[1] = stateFromStores;
+  env19017[2] = useStateFromStores([GuildPowerupsStore], $mk87697(r13));
+  const r3 = stateFromStores == null;
+  let r25 = void 0;
+  if (!r3) {
+    const features = stateFromStores.features;
+    r25 = features == null ? void 0 : features.has(GuildFeatures.PREMIUM_TIER_3_OVERRIDE);
+  }
+  if (r25 == null) {
+    r25 = false;
+  }
+  env19017[3] = r25;
+  const r33 = r7.map($mk87698(r13));
+  return r33.length <= 0 ? {
+    type: PowerupActiveStatusType.INACTIVE,
+    sourceEntitlement: void 0,
+    sourcePowerup: void 0
+  } : r33[0];
+};
+export function isPowerupActiveStatusActive(a0) {
+  return a0.type !== PowerupActiveStatusType.INACTIVE;
+}
+export function usePowerupsActiveStatuses(a0, a1) {
+  let env19016;
+  const r3 = env19016 = {
+    $parent: env7908
+  };
+  env19016[0] = a0;
+  const stateFromStores = useStateFromStores([GuildStore], $mk87696(r3));
+  env19016[1] = stateFromStores;
+  env19016[2] = useStateFromStores([GuildPowerupsStore], $mk87697(r3));
+  const r2 = stateFromStores == null;
+  let r22 = void 0;
+  if (!r2) {
+    const features = stateFromStores.features;
+    r22 = features == null ? void 0 : features.has(GuildFeatures.PREMIUM_TIER_3_OVERRIDE);
+  }
+  if (r22 == null) {
+    r22 = false;
+  }
+  env19016[3] = r22;
+  return a1.map($mk87698(r3));
+}

modules/premium/powerups/hooks/useShouldShowGuildThemeMemberCoachmark.tsx

@@ -0,0 +1,32 @@
+// Metro module 15131 (f15132).
+import { GUILD_THEME_POWERUP_BOOST_PRICE } from "../constants/GuildPowerupsConstants";
+import useHasAllocateBoostPermission from "./useHasAllocateBoostPermission";
+import { useServerThemeEnabled } from "../experiments/ServerThemeExperiment";
+import { useServerThemeUserEnabled } from "../experiments/ServerThemeUserExperiment";
+import useIsGuildThemePerkEnabled from "./useIsGuildThemePerkEnabled";
+import useGuildPowerupsBoostCount from "./useGuildPowerupsBoostCount";
+export default function useShouldShowGuildThemeMemberCoachmark(a0) {
+  const hasAllocateBoostPermission = useHasAllocateBoostPermission(a0);
+  let r13 = useServerThemeEnabled(a0, "useShouldShowGuildThemeMemberCoachmark");
+  const serverThemeUserEnabled = useServerThemeUserEnabled("useShouldShowGuildThemeMemberCoachmark");
+  const isGuildThemePerkEnabled = useIsGuildThemePerkEnabled(a0);
+  const guildPowerupsBoostCount = useGuildPowerupsBoostCount(a0);
+  const { available, isLoading } = guildPowerupsBoostCount;
+  let r26 = !isLoading;
+  if (!isLoading) {
+    if (r13) {
+      r13 = serverThemeUserEnabled;
+    }
+    if (r13) {
+      r13 = available < GUILD_THEME_POWERUP_BOOST_PRICE;
+    }
+    if (r13) {
+      r13 = !isGuildThemePerkEnabled;
+    }
+    if (r13) {
+      r13 = hasAllocateBoostPermission === false;
+    }
+    r26 = r13;
+  }
+  return r26;
+};

modules/premium/powerups/hooks/useTotalPossibleBoostCount.tsx

@@ -0,0 +1,28 @@
+// Metro module 15188 (f15189).
+import { useMemo } from "react";
+import { MULTIPLE_PURCHASEABLE_PREMIUM_FEATURES_BOOST_INFO, PURCHASABLE_PREMIUM_FEATURES_BOOST_INFO } from "../constants/GuildPowerupsConstants";
+import { AppliedGuildBoostsRequiredForBoostedGuildTier, BoostedGuildTiers, GuildFeatures } from "../../../../Constants";
+export default function useTotalPossibleBoostCount(a0) {
+  return useMemo(() => {
+    if (a0 == null) {
+      return 0;
+    }
+    const r14 = (a0 == null ? void 0 : a0.features.has(GuildFeatures.PREMIUM_TIER_3_OVERRIDE)) !== true ? AppliedGuildBoostsRequiredForBoostedGuildTier[BoostedGuildTiers.TIER_3] : 0;
+    let c27960_0 = r14;
+    Object.values(PURCHASABLE_PREMIUM_FEATURES_BOOST_INFO).concat(Object.values(MULTIPLE_PURCHASEABLE_PREMIUM_FEATURES_BOOST_INFO)).forEach((item) => {
+      let r8 = item.includedInLevel == null;
+      if (r8) {
+        const isEnabled = item.isEnabled;
+        let r5 = isEnabled == null ? void 0 : isEnabled.call(item, a0.id);
+        if (r5 == null) {
+          r5 = 1;
+        }
+        r8 = r5;
+      }
+      if (r8) {
+        c27960_0 = c27960_0 + item.boostPrice;
+      }
+    });
+    return c27960_0;
+  }, [a0]);
+};