@greatapps/common 1.1.790 → 1.1.792

package/dist/components/account/sections/subscription/change-plan/useChangePlanState.mjs

@@ -0,0 +1,918 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { useForm } from "react-hook-form";
+import { useStripe } from "@stripe/react-stripe-js";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useTranslations } from "next-intl";
+import { toast } from "sonner";
+import z from "zod";
+import { Toast } from "../../../../ui/feedback/Toast";
+import { useCurrentAccount } from "../../../../../modules/accounts/hooks/current-account.hook";
+import { useCurrencyFormatter } from "../../../../../modules/accounts/hooks/use-currency-formatter.hook";
+import {
+  hasCompleteBillingData,
+  isBrazilianBillingAccount
+} from "../../../../../modules/accounts/utils/billing-data";
+import { useCards } from "../../../../../modules/cards/hooks/cards.hook";
+import { useCouponById } from "../../../../../modules/coupons/hooks/use-coupon-by-id.hook";
+import {
+  getCouponRestrictions,
+  isCouponApplicableToPlan
+} from "../../../../../modules/coupons/utils/coupon-restrictions";
+import { useCountDomains } from "../../../../../modules/domains/hooks/count-domains.hook";
+import { usePlanById } from "../../../../../modules/plans/hooks/use-plan-by-id.hook";
+import {
+  ADDON_IDS,
+  buildAiCreditOptions,
+  canBuyExtraDomains,
+  getDomainExtraPrice
+} from "../../../../../modules/subscriptions/constants/addons.constants";
+import { useCalculateSubscription } from "../../../../../modules/subscriptions/hooks/calculate-subscription.hook";
+import { useCreateSubscription } from "../../../../../modules/subscriptions/hooks/create-subscription.hook";
+import { useCurrentSubscription } from "../../../../../modules/subscriptions/hooks/use-current-subscription.hook";
+import { useUpdateSubscriptionPlan } from "../../../../../modules/subscriptions/hooks/update-subscription-plan.hook";
+import { isPendingPixCreateSubscriptionResponse } from "../../../../../modules/subscriptions/types/create-subscription.type";
+import { confirmPaymentIfRequired, PaymentAuthenticationError } from "../../../../../modules/subscriptions/utils/confirm-payment-if-required";
+import {
+  getAddonBuckets,
+  buildDomainPlanExtras,
+  buildZeroedOldBuckets
+} from "../../../../../modules/subscriptions/utils/addon-buckets";
+import {
+  getFirstPeriodPricing
+} from "../../../../../modules/subscriptions/utils/first-period-pricing";
+import { isBoletoAvailable, isBoletoPayer } from "../../../../../modules/subscriptions/utils/is-boleto-payer";
+import {
+  billingPeriodToNumeric,
+  getBillingPeriodLabel,
+  getBillingPeriodMonths,
+  getBillingPeriodSuffix,
+  getCouponDiscount,
+  getDiscount,
+  getEffectiveDiscountPercent,
+  getPeriodPricingKey,
+  getPeriodicityLabel,
+  getPriceFromCalculatedData,
+  periodicityToBillingPeriod
+} from "../../../../../modules/subscriptions/utils/periodicity";
+import { resolveSubscriptionPlanName } from "../../../../../modules/subscriptions/utils/resolve-subscription-plan-name";
+import { useWhitelabel } from "../../../../../providers/whitelabel.provider";
+import { useDebouncedEffect } from "../../../../../hooks/useDebouncedEffect";
+import { useSubscriptionFlows } from "../../../../../store/useSubscriptionFlows";
+const MIN_DOMAINS = 1;
+const changePlanSchema = z.object({
+  paymentMethod: z.enum(["card", "boleto", "pix"]),
+  selectedCardId: z.string(),
+  selectedReason: z.string(),
+  reasonText: z.string()
+});
+const ChangePlanContext = createContext(null);
+const ChangePlanProvider = ChangePlanContext.Provider;
+function useChangePlan() {
+  const context = useContext(ChangePlanContext);
+  if (!context) throw new Error("useChangePlan precisa estar dentro de ChangePlanProvider");
+  return context;
+}
+function readProrataValueCents(response) {
+  const value = response.prorata_value_cents;
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+const paymentMethodToNumeric = (method) => method === "card" ? 1 : method === "boleto" ? 2 : 3;
+function useChangePlanLogic() {
+  const translate = useTranslations();
+  const { whitelabel } = useWhitelabel();
+  const stripe = useStripe();
+  const { data: account } = useCurrentAccount();
+  const { currency, formatCurrencyNumber } = useCurrencyFormatter();
+  const isUsdAccount = currency === "usd";
+  const changePlan = useSubscriptionFlows((state) => state.changePlan);
+  const closeChangePlan = useSubscriptionFlows((state) => state.closeChangePlan);
+  const openPlansCatalog = useSubscriptionFlows((state) => state.openPlansCatalog);
+  const openPixPayment = useSubscriptionFlows((state) => state.openPixPayment);
+  const openBoletoGenerated = useSubscriptionFlows((state) => state.openBoletoGenerated);
+  const openBillingAddress = useSubscriptionFlows((state) => state.openBillingAddress);
+  const openPaymentConfirmation = useSubscriptionFlows((state) => state.openPaymentConfirmation);
+  const open = !!changePlan;
+  const data = changePlan ?? void 0;
+  const isReactivation = data?.isReactivation ?? false;
+  const { mutateAsync: updatePlanAsync } = useUpdateSubscriptionPlan();
+  const { mutateAsync: createSubscriptionAsync } = useCreateSubscription();
+  const { data: cardsData } = useCards();
+  const { data: subscriptionData, isFetched: activeSubscriptionFetched } = useCurrentSubscription();
+  const activeSubscription = subscriptionData?.data?.[0];
+  const subscriptionCouponId = activeSubscription?.id_coupon != null ? Number(activeSubscription.id_coupon) : null;
+  const { data: subscriptionCouponData } = useCouponById(
+    open && subscriptionCouponId != null ? subscriptionCouponId : null
+  );
+  const { mutate: calculate, isPending: isCalculatePending, data: calculateData } = useCalculateSubscription();
+  const [currentStep, setCurrentStep] = useState(1);
+  const [selectedCreditIndex, setSelectedCreditIndex] = useState(0);
+  const [bucketEdits, setBucketEdits] = useState({});
+  const [abTestEnabled, setAbTestEnabled] = useState(false);
+  const [appliedCouponId, setAppliedCouponId] = useState(null);
+  const [appliedCouponCode, setAppliedCouponCode] = useState(null);
+  const [appliedCouponStripeData, setAppliedCouponStripeData] = useState(null);
+  const [activeCardIdAddon, setActiveCardIdAddon] = useState("");
+  const [abTestDetailsOpen, setAbTestDetailsOpen] = useState(false);
+  const [isCouponDialogOpen, setIsCouponDialogOpen] = useState(false);
+  const [isReactivating, setIsReactivating] = useState(false);
+  const [pendingAuthSecret, setPendingAuthSecret] = useState(null);
+  const pendingUpdatePayloadRef = useRef(null);
+  const hasInitialized = useRef(false);
+  const targetPlan = data?.targetPlan;
+  const isDowngrade = data?.isDowngrade ?? false;
+  const { data: currentPlanData } = usePlanById(activeSubscription?.id_plan);
+  const currentPlan = currentPlanData?.data;
+  const effectivePlan = targetPlan ?? currentPlan;
+  const effectivePlanId = targetPlan ? targetPlan.planId : currentPlan?.id;
+  const wlName = whitelabel?.name || "";
+  const subscriptionBillingPeriod = periodicityToBillingPeriod(activeSubscription?.periodicity) ?? "monthly";
+  const requestedBillingPeriod = data?.billingPeriod ?? subscriptionBillingPeriod;
+  const [contractingBillingPeriod, setContractingBillingPeriod] = useState(null);
+  const billingPeriod = isReactivation && contractingBillingPeriod ? contractingBillingPeriod : requestedBillingPeriod;
+  const modalBillingPeriod = data?.billingPeriod ?? "monthly";
+  const subscriptionItems = activeSubscription?.items ?? [];
+  const domainItems = subscriptionItems.filter((item) => item.id_addon === ADDON_IDS.DOMAINS);
+  const abTestItem = subscriptionItems.find((item) => item.id_addon === ADDON_IDS.AB_TEST);
+  const aiItems = subscriptionItems.filter(
+    (item) => item.id_addon === ADDON_IDS.AI && (item.value ?? 0) > 0
+  );
+  const aiItem = aiItems.length > 0 ? aiItems.reduce((best, item) => item.quantity > best.quantity ? item : best) : void 0;
+  const planDomainItem = effectivePlan?.items.find(
+    (item) => item.id_addon === ADDON_IDS.DOMAINS && item.value == 0
+  );
+  const planAbTestItem = effectivePlan?.items.find((item) => item.id_addon === ADDON_IDS.AB_TEST);
+  const aiCreditOptions = buildAiCreditOptions(effectivePlan?.items ?? []);
+  const selectedCredit = aiCreditOptions[selectedCreditIndex] ?? aiCreditOptions[0];
+  const hasDomainsAddon = !!effectivePlan?.items.find((item) => item.id_addon === ADDON_IDS.DOMAINS && item.value > 0) && canBuyExtraDomains(effectivePlanId);
+  const planAbTestIncludedItem = effectivePlan?.items.find(
+    (item) => item.id_addon === ADDON_IDS.AB_TEST && (item.value ?? 0) === 0 && (item.quantity ?? 0) > 0
+  );
+  const abTestIncludedInPlan = !!planAbTestIncludedItem;
+  const hasAbTestAddon = !abTestIncludedInPlan && !!effectivePlan?.items.find((item) => item.id_addon === ADDON_IDS.AB_TEST && (item.value ?? 0) > 0);
+  const { data: registeredDomains = 0, isSuccess: registeredDomainsLoaded } = useCountDomains({
+    enabled: open
+  });
+  const planDomainItems = effectivePlan?.items.filter(
+    (item) => item.id_addon === ADDON_IDS.DOMAINS && (item.value ?? 0) > 0
+  );
+  const planDomainPrice = planDomainItems?.find((item) => item.base)?.value ?? planDomainItems?.[0]?.value ?? getDomainExtraPrice(effectivePlanId);
+  const domainPriceMonthly = planDomainPrice;
+  const subscriptionAbTestPrice = subscriptionItems.find((item) => item.id_addon === ADDON_IDS.AB_TEST && (item.value ?? 0) > 0)?.value ?? 0;
+  const abTestPriceMonthly = subscriptionAbTestPrice || (planAbTestItem?.value ?? 0);
+  const abTestPayloadQuantity = abTestIncludedInPlan ? planAbTestIncludedItem?.quantity ?? 1 : abTestEnabled ? 1 : 0;
+  const subscriptionIncludedDomainsItem = domainItems.find((item) => (item.value ?? 0) === 0);
+  const planIncludedDomains = targetPlan ? planDomainItem?.quantity ?? MIN_DOMAINS : subscriptionIncludedDomainsItem?.quantity ?? planDomainItem?.quantity ?? MIN_DOMAINS;
+  const currentPlanIncludedDomains = effectivePlan?.items?.find((item) => item.id_addon === ADDON_IDS.DOMAINS)?.quantity ?? 0;
+  const subscriptionDomainSum = domainItems.reduce((sum, item) => sum + (item.quantity ?? 0), 0);
+  const subscriptionExtraDomains = domainItems.filter((item) => (item.value ?? 0) > 0).reduce((sum, item) => sum + (item.quantity ?? 0), 0);
+  const currentSubscriptionDomains = Math.max(
+    subscriptionDomainSum,
+    currentPlanIncludedDomains + subscriptionExtraDomains
+  );
+  const collapseToSingleBucket = isReactivation || !!targetPlan;
+  const primaryBucketPrice = planDomainPrice;
+  const domainBuckets = getAddonBuckets(
+    ADDON_IDS.DOMAINS,
+    collapseToSingleBucket ? [] : subscriptionItems,
+    primaryBucketPrice,
+    bucketEdits
+  );
+  const zeroedOldDomainBuckets = targetPlan ? buildZeroedOldBuckets(ADDON_IDS.DOMAINS, subscriptionItems, planDomainPrice) : [];
+  const primaryBucket = domainBuckets.find((bucket) => bucket.isPrimary);
+  const alternativeBuckets = domainBuckets.filter((bucket) => !bucket.isPrimary && bucket.quantity > 0);
+  const hasAlternativeBuckets = domainBuckets.some(
+    (bucket) => !bucket.isPrimary && bucket.originalQuantity > 0
+  );
+  const totalExtras = domainBuckets.reduce((sum, bucket) => sum + bucket.quantity, 0);
+  const totalDomains = planIncludedDomains + totalExtras;
+  const domains = planIncludedDomains + primaryBucket.quantity;
+  const minDomains = registeredDomainsLoaded ? Math.max(planIncludedDomains, registeredDomains) : planIncludedDomains;
+  const domainsCountLoading = hasDomainsAddon && !registeredDomainsLoaded;
+  const isAtMin = totalDomains <= minDomains || primaryBucket.quantity <= 0;
+  const extraDomains = totalExtras;
+  const paymentMethodFromSubscription = activeSubscription?.payment_method === 2 ? "boleto" : activeSubscription?.payment_method === 3 ? "pix" : "card";
+  const form = useForm({
+    resolver: zodResolver(changePlanSchema),
+    defaultValues: { paymentMethod: "card", selectedCardId: "", selectedReason: "", reasonText: "" }
+  });
+  const { isSubmitting } = form.formState;
+  const paymentMethod = form.watch("paymentMethod");
+  const selectedCardId = form.watch("selectedCardId");
+  const paymentDefaultAppliedRef = useRef(false);
+  useEffect(() => {
+    if (!open) {
+      paymentDefaultAppliedRef.current = false;
+      return;
+    }
+    if (paymentDefaultAppliedRef.current || !activeSubscription) return;
+    form.setValue("paymentMethod", paymentMethodFromSubscription);
+    paymentDefaultAppliedRef.current = true;
+  }, [open, activeSubscription, paymentMethodFromSubscription, form]);
+  const couponRestrictions = getCouponRestrictions(appliedCouponStripeData);
+  const { allowedPaymentMethod, disabledPaymentMethods } = couponRestrictions;
+  const { disabledBillingPeriods, allowedBillingPeriod } = couponRestrictions;
+  const { unlocksAllPaymentMethods: couponUnlocksAllMethods } = couponRestrictions;
+  const isCurrentSubscriptionBoleto = isBoletoPayer(activeSubscription?.payment_method);
+  const allowBoletoFromCurrentSubscription = isCurrentSubscriptionBoleto && !targetPlan && !isReactivation;
+  const isCurrentSubscriptionPix = activeSubscription?.payment_method === 3;
+  const allowPixFromCurrentSubscription = isCurrentSubscriptionPix && !targetPlan && !isReactivation;
+  const boletoAvailable = !isUsdAccount && isBoletoAvailable({
+    isBoletoPayer: isCurrentSubscriptionBoleto,
+    allowedPaymentMethod,
+    unlocksAllPaymentMethods: couponUnlocksAllMethods
+  });
+  const pixAvailable = !isUsdAccount;
+  useEffect(() => {
+    if (!open) return;
+    if (isUsdAccount) {
+      if (paymentMethod !== "card") form.setValue("paymentMethod", "card");
+      return;
+    }
+    if (!allowedPaymentMethod) return;
+    if (paymentMethod !== allowedPaymentMethod) form.setValue("paymentMethod", allowedPaymentMethod);
+  }, [open, isUsdAccount, allowedPaymentMethod, paymentMethod, form]);
+  useEffect(() => {
+    if (!open) return;
+    if (billingPeriod === "annual") return;
+    if (paymentMethod !== "boleto" && paymentMethod !== "pix") return;
+    if (couponUnlocksAllMethods) return;
+    if (paymentMethod === "boleto" && (allowedPaymentMethod === "boleto" || allowBoletoFromCurrentSubscription)) {
+      return;
+    }
+    if (paymentMethod === "pix" && (allowedPaymentMethod === "pix" || allowPixFromCurrentSubscription)) {
+      return;
+    }
+    form.setValue("paymentMethod", "card");
+  }, [
+    open,
+    billingPeriod,
+    paymentMethod,
+    couponUnlocksAllMethods,
+    allowedPaymentMethod,
+    allowBoletoFromCurrentSubscription,
+    allowPixFromCurrentSubscription,
+    form
+  ]);
+  useEffect(() => {
+    if (!open || boletoAvailable || paymentMethod !== "boleto") return;
+    form.setValue("paymentMethod", "card");
+  }, [open, boletoAvailable, paymentMethod, form]);
+  const cards = cardsData?.data ?? [];
+  const defaultCardId = (cards.find((card) => card.is_default) ?? cards[0])?.id?.toString() ?? "";
+  const resolvedAddonCardId = activeCardIdAddon || defaultCardId;
+  useEffect(() => {
+    if (!open || !activeSubscription || !effectivePlan || !registeredDomainsLoaded) return;
+    if (hasInitialized.current) return;
+    hasInitialized.current = true;
+    if (hasDomainsAddon) {
+      if (collapseToSingleBucket) {
+        const primaryKey = `${ADDON_IDS.DOMAINS}_${planDomainPrice}`;
+        const initialQty = Math.max(0, registeredDomains - planIncludedDomains);
+        if (initialQty > 0) setBucketEdits((previous) => ({ ...previous, [primaryKey]: initialQty }));
+      } else {
+        const initBuckets = getAddonBuckets(ADDON_IDS.DOMAINS, subscriptionItems, domainPriceMonthly, {});
+        const initExtras = initBuckets.reduce((sum, bucket) => sum + bucket.quantity, 0);
+        const deficit = Math.max(0, minDomains - (planIncludedDomains + initExtras));
+        if (deficit > 0) {
+          const primary = initBuckets.find((bucket) => bucket.isPrimary);
+          setBucketEdits((previous) => ({ ...previous, [primary.key]: primary.quantity + deficit }));
+        }
+      }
+    }
+    setAbTestEnabled(hasAbTestAddon && !!abTestItem);
+    if (aiItem) {
+      const aiIndex = aiCreditOptions.findIndex((option) => option.credits === aiItem.quantity);
+      if (aiIndex >= 0) setSelectedCreditIndex(aiIndex);
+    } else if (data?.selectedCreditIndex != null) {
+      setSelectedCreditIndex(data.selectedCreditIndex);
+    }
+    if (subscriptionCouponId != null) setAppliedCouponId(subscriptionCouponId);
+  }, [
+    open,
+    activeSubscription,
+    effectivePlan,
+    registeredDomainsLoaded,
+    hasDomainsAddon,
+    minDomains,
+    currentSubscriptionDomains,
+    data,
+    subscriptionCouponId
+  ]);
+  useEffect(() => {
+    if (!open) return;
+    const coupon = subscriptionCouponData?.data;
+    if (!coupon || appliedCouponId !== subscriptionCouponId) return;
+    if (coupon.code && !appliedCouponCode) setAppliedCouponCode(coupon.code);
+    if (coupon.stripe_data && !appliedCouponStripeData) setAppliedCouponStripeData(coupon.stripe_data);
+  }, [
+    open,
+    subscriptionCouponData,
+    subscriptionCouponId,
+    appliedCouponId,
+    appliedCouponCode,
+    appliedCouponStripeData
+  ]);
+  const cardDefaultAppliedRef = useRef(false);
+  useEffect(() => {
+    if (!open) {
+      cardDefaultAppliedRef.current = false;
+      return;
+    }
+    if (cards.length === 0) return;
+    const currentId = form.getValues("selectedCardId");
+    const isValid = currentId !== "" && cards.some((card) => card.id.toString() === currentId);
+    if (cardDefaultAppliedRef.current) {
+      if (!isValid) {
+        const fallbackCard = cards.find((card) => card.is_default) ?? cards[0];
+        form.setValue("selectedCardId", fallbackCard.id.toString());
+      }
+      return;
+    }
+    if (!activeSubscriptionFetched) return;
+    const subscriptionCardId2 = activeSubscription?.id_card != null ? String(activeSubscription.id_card) : null;
+    const subscriptionCard = subscriptionCardId2 ? cards.find((card) => card.id.toString() === subscriptionCardId2) : void 0;
+    const nextCard = subscriptionCard ?? cards.find((card) => card.is_default) ?? cards[0];
+    form.setValue("selectedCardId", nextCard.id.toString());
+    cardDefaultAppliedRef.current = true;
+  }, [cardsData, open, form, cards, activeSubscription, activeSubscriptionFetched]);
+  useEffect(() => {
+    if (open) return;
+    form.reset();
+    setCurrentStep(1);
+    setAppliedCouponId(null);
+    setAppliedCouponCode(null);
+    setAppliedCouponStripeData(null);
+    setActiveCardIdAddon("");
+    setSelectedCreditIndex(0);
+    setBucketEdits({});
+    setContractingBillingPeriod(null);
+    setPendingAuthSecret(null);
+    pendingUpdatePayloadRef.current = null;
+    hasInitialized.current = false;
+  }, [open, form]);
+  const { isDebouncing } = useDebouncedEffect({
+    effect: () => {
+      if (!effectivePlan) return;
+      const credit = aiCreditOptions[selectedCreditIndex] ?? aiCreditOptions[0];
+      calculate({
+        id_product: 1,
+        id_plan: effectivePlanId,
+        periodicity: billingPeriodToNumeric(billingPeriod),
+        ...activeSubscription?.id != null && { id_subscription: activeSubscription.id },
+        ...appliedCouponId != null && { id_coupon: appliedCouponId },
+        plan_extras: [
+          { id_addon: ADDON_IDS.AI, quantity: credit.credits },
+          // Só os buckets do plano-alvo: o backend não sabe precificar um domínio num preço
+          // que não é do plano calculado (ex.: extra legado de R$ 9,90 indo para um plano de
+          // R$ 14,90) e recusa a prévia inteira. Zerar os legados é papel do update.
+          ...buildDomainPlanExtras(domainBuckets),
+          { id_addon: ADDON_IDS.AB_TEST, quantity: abTestPayloadQuantity }
+        ]
+      });
+    },
+    debouncedDeps: [selectedCreditIndex, bucketEdits, abTestPayloadQuantity],
+    immediateDeps: [open, effectivePlan, appliedCouponId, activeSubscription?.items],
+    delay: 500
+  });
+  const hasChangedPaymentMethod = !!activeSubscription && paymentMethod !== paymentMethodFromSubscription;
+  const hasChangedCoupon = appliedCouponId !== subscriptionCouponId;
+  const subscriptionCardId = activeSubscription?.id_card != null ? String(activeSubscription.id_card) : null;
+  const hasChangedCard = !!activeSubscription && paymentMethod === "card" && paymentMethodFromSubscription === "card" && selectedCardId !== "" && subscriptionCardId !== selectedCardId;
+  const hasChanges = !!targetPlan || billingPeriod !== subscriptionBillingPeriod || selectedCredit.credits !== (aiItem?.quantity ?? 0) || abTestEnabled !== (hasAbTestAddon && !!abTestItem) || domainBuckets.some((bucket) => bucket.quantity !== bucket.originalQuantity) || hasChangedPaymentMethod || hasChangedCoupon || hasChangedCard;
+  const requiresBillingData = (paymentMethod === "boleto" || paymentMethod === "pix") && !!account && isBrazilianBillingAccount(account) && !hasCompleteBillingData(account);
+  const isCalculating = isDebouncing || isCalculatePending;
+  const calculatedData = calculateData?.data ?? null;
+  const totalPrice = calculatedData ? getPriceFromCalculatedData(calculatedData, billingPeriodToNumeric(billingPeriod)) : null;
+  const discountAmount = getDiscount(calculatedData, billingPeriod);
+  const couponDiscountAmount = getCouponDiscount(calculatedData, billingPeriod);
+  const immediateCharge = calculatedData?.target?.immediate_charge ?? null;
+  const calculatedPricing = calculatedData ? { monthly: calculatedData.month, annual: calculatedData.year } : null;
+  const billingDiscounts = {
+    monthly: getEffectiveDiscountPercent(calculatedData, "monthly"),
+    annual: getEffectiveDiscountPercent(calculatedData, "annual")
+  };
+  const firstPeriodPricingByPeriod = calculatedData ? {
+    monthly: getFirstPeriodPricing({
+      stripeData: appliedCouponStripeData,
+      total: calculatedData.month,
+      couponDiscount: calculatedData.month_discount_coupom ?? 0
+    }),
+    annual: getFirstPeriodPricing({
+      stripeData: appliedCouponStripeData,
+      total: calculatedData.year,
+      couponDiscount: calculatedData.year_discount_coupom ?? 0
+    })
+  } : null;
+  const billingLabel = getBillingPeriodLabel(billingPeriod, translate);
+  const periodMonths = getBillingPeriodMonths(billingPeriod);
+  const periodPricingKey = getPeriodPricingKey(billingPeriod);
+  const currentBillingPeriod = periodicityToBillingPeriod(activeSubscription?.periodicity) ?? "monthly";
+  const currentPeriodLabel = getBillingPeriodSuffix(currentBillingPeriod, translate);
+  const periodLabel = getBillingPeriodSuffix(billingPeriod, translate);
+  const billingLabelFull = getBillingPeriodLabel(billingPeriod, translate);
+  const handleDecreaseDomains = useCallback(() => {
+    if (primaryBucket.quantity <= 0) return;
+    if (totalDomains <= minDomains) return;
+    setBucketEdits((previous) => ({ ...previous, [primaryBucket.key]: primaryBucket.quantity - 1 }));
+  }, [primaryBucket, totalDomains, minDomains]);
+  const handleIncreaseDomains = useCallback(() => {
+    setBucketEdits((previous) => ({ ...previous, [primaryBucket.key]: primaryBucket.quantity + 1 }));
+  }, [primaryBucket]);
+  const handleDomainsChange = useCallback(
+    (event) => {
+      const requested = Number.parseInt(event.target.value, 10);
+      if (Number.isNaN(requested)) return;
+      const requestedPrimary = requested - planIncludedDomains;
+      const altTotal = domainBuckets.filter((bucket) => !bucket.isPrimary).reduce((sum, bucket) => sum + bucket.quantity, 0);
+      const minPrimary = Math.max(0, minDomains - planIncludedDomains - altTotal);
+      setBucketEdits((previous) => ({
+        ...previous,
+        [primaryBucket.key]: Math.max(minPrimary, requestedPrimary)
+      }));
+    },
+    [minDomains, planIncludedDomains, primaryBucket, domainBuckets]
+  );
+  const handleAlternativeDecrease = useCallback(
+    (bucket) => {
+      if (bucket.quantity <= 0) return;
+      if (totalDomains - 1 < minDomains) return;
+      setBucketEdits((previous) => ({ ...previous, [bucket.key]: bucket.quantity - 1 }));
+    },
+    [totalDomains, minDomains]
+  );
+  const handleAlternativeIncrease = useCallback((bucket) => {
+    if (bucket.quantity >= bucket.originalQuantity) return;
+    setBucketEdits((previous) => ({ ...previous, [bucket.key]: bucket.quantity + 1 }));
+  }, []);
+  const handleApplyCoupon = useCallback(
+    (coupon) => {
+      const stripeData = coupon.stripeData ?? null;
+      if (!isCouponApplicableToPlan(stripeData, effectivePlanId)) {
+        toast.custom((toastId) => /* @__PURE__ */ jsx(
+          Toast,
+          {
+            variant: "error",
+            message: translate("common.account.workspace.subscription.changePlan.toasts.couponNotValidForPlan", {
+              code: coupon.code
+            }),
+            toastId
+          }
+        ));
+        return;
+      }
+      const { disabledBillingPeriods: blockedPeriods } = getCouponRestrictions(stripeData);
+      if (blockedPeriods.includes(billingPeriod)) {
+        toast.custom((toastId) => /* @__PURE__ */ jsx(
+          Toast,
+          {
+            variant: "error",
+            message: translate("common.account.workspace.subscription.changePlan.toasts.couponNotValidForPeriod", {
+              code: coupon.code
+            }),
+            toastId
+          }
+        ));
+        return;
+      }
+      setAppliedCouponId(coupon.id);
+      setAppliedCouponCode(coupon.code);
+      setAppliedCouponStripeData(stripeData);
+    },
+    [effectivePlanId, billingPeriod, translate]
+  );
+  const handleRemoveCoupon = useCallback(() => {
+    setAppliedCouponId(null);
+    setAppliedCouponCode(null);
+    setAppliedCouponStripeData(null);
+  }, []);
+  useEffect(() => {
+    if (!appliedCouponStripeData || effectivePlanId == null) return;
+    if (isCouponApplicableToPlan(appliedCouponStripeData, effectivePlanId)) return;
+    const code = appliedCouponCode;
+    handleRemoveCoupon();
+    toast.custom((toastId) => /* @__PURE__ */ jsx(
+      Toast,
+      {
+        variant: "warning",
+        message: translate("common.account.workspace.subscription.changePlan.toasts.couponRemovedInvalidPlan", {
+          code: code ?? ""
+        }),
+        toastId
+      }
+    ));
+  }, [effectivePlanId, appliedCouponStripeData, appliedCouponCode, handleRemoveCoupon, translate]);
+  useEffect(() => {
+    if (!appliedCouponStripeData) return;
+    if (!disabledBillingPeriods.includes(billingPeriod)) return;
+    const code = appliedCouponCode;
+    handleRemoveCoupon();
+    toast.custom((toastId) => /* @__PURE__ */ jsx(
+      Toast,
+      {
+        variant: "warning",
+        message: translate("common.account.workspace.subscription.changePlan.toasts.couponRemovedInvalidPeriod", {
+          code: code ?? ""
+        }),
+        toastId
+      }
+    ));
+  }, [
+    billingPeriod,
+    disabledBillingPeriods,
+    appliedCouponStripeData,
+    appliedCouponCode,
+    handleRemoveCoupon,
+    translate
+  ]);
+  const handleClose = useCallback(() => {
+    setCurrentStep(1);
+    closeChangePlan();
+  }, [closeChangePlan]);
+  const handleBack = useCallback(() => setCurrentStep((previous) => Math.max(1, previous - 1)), []);
+  const handleContinue = useCallback(() => setCurrentStep((previous) => previous + 1), []);
+  const handleOpenCouponDialog = useCallback(() => setIsCouponDialogOpen(true), []);
+  const handleOpenPlansCatalog = useCallback(() => {
+    closeChangePlan();
+    openPlansCatalog({ appliedCouponStripeData });
+  }, [closeChangePlan, openPlansCatalog, appliedCouponStripeData]);
+  const handleReactivate = useCallback(async () => {
+    const reactivationPlanId = effectivePlanId ?? activeSubscription?.id_plan;
+    if (!reactivationPlanId) return;
+    if (pendingAuthSecret) {
+      setIsReactivating(true);
+      try {
+        await confirmPaymentIfRequired(
+          stripe,
+          { client_secret: pendingAuthSecret },
+          translate("common.payment.authFailed")
+        );
+        setPendingAuthSecret(null);
+        handleClose();
+        openPaymentConfirmation({
+          planName: targetPlan?.name ?? resolveSubscriptionPlanName(activeSubscription, translate),
+          total: totalPrice ?? 0,
+          periodLabel: getBillingPeriodSuffix(billingPeriod, translate),
+          immediateChargeTotal: null
+        });
+      } catch (error) {
+        toast.custom((toastId) => /* @__PURE__ */ jsx(
+          Toast,
+          {
+            variant: "error",
+            message: error instanceof Error ? error.message : translate("common.payment.authFailed"),
+            toastId
+          }
+        ));
+      } finally {
+        setIsReactivating(false);
+      }
+      return;
+    }
+    setIsReactivating(true);
+    try {
+      const result = await createSubscriptionAsync({
+        id_product: activeSubscription?.id_product ?? 1,
+        id_plan: reactivationPlanId,
+        type: "client",
+        payment_method: paymentMethodToNumeric(paymentMethod),
+        periodicity: billingPeriodToNumeric(billingPeriod),
+        ...appliedCouponId != null && { id_coupon: appliedCouponId },
+        ...paymentMethod === "card" && selectedCardId ? { id_card: selectedCardId } : {},
+        plan_items: [
+          { id_addon: ADDON_IDS.AI, quantity: selectedCredit.credits },
+          ...buildDomainPlanExtras(domainBuckets),
+          { id_addon: ADDON_IDS.AB_TEST, quantity: abTestPayloadQuantity }
+        ]
+      });
+      const created = Array.isArray(result?.data) ? result.data[0] : result?.data;
+      handleClose();
+      if (paymentMethod === "pix") {
+        if (created && isPendingPixCreateSubscriptionResponse(created)) {
+          openPixPayment({
+            qrCode: created.pix.qr_code ?? null,
+            expiresAt: created.pix.expires_at ?? null,
+            correlationId: created.pix.correlation_id,
+            payNowCents: readProrataValueCents(created)
+          });
+        } else {
+          toast.custom((toastId) => /* @__PURE__ */ jsx(
+            Toast,
+            {
+              variant: "error",
+              message: translate("common.account.workspace.subscription.changePlan.toasts.pixNotGenerated"),
+              toastId
+            }
+          ));
+        }
+        return;
+      }
+      if (paymentMethod === "boleto") {
+        const createdId = created?.id;
+        if (createdId != null) {
+          openBoletoGenerated({ subscriptionId: createdId });
+          return;
+        }
+      }
+      toast.custom((toastId) => /* @__PURE__ */ jsx(
+        Toast,
+        {
+          variant: "success",
+          message: translate("common.account.workspace.subscription.changePlan.toasts.planReactivated", {
+            planName: targetPlan?.name ?? resolveSubscriptionPlanName(activeSubscription, translate)
+          }),
+          toastId
+        }
+      ));
+    } catch (error) {
+      if (error instanceof PaymentAuthenticationError && error.clientSecret) {
+        setPendingAuthSecret(error.clientSecret);
+      }
+      toast.custom((toastId) => /* @__PURE__ */ jsx(
+        Toast,
+        {
+          variant: "error",
+          message: error instanceof PaymentAuthenticationError ? error.message : translate("common.account.workspace.subscription.changePlan.toasts.reactivateError"),
+          toastId
+        }
+      ));
+    } finally {
+      setIsReactivating(false);
+    }
+  }, [
+    activeSubscription,
+    effectivePlanId,
+    targetPlan,
+    billingPeriod,
+    appliedCouponId,
+    selectedCredit,
+    domainBuckets,
+    abTestPayloadQuantity,
+    paymentMethod,
+    selectedCardId,
+    handleClose,
+    createSubscriptionAsync,
+    openPixPayment,
+    openBoletoGenerated,
+    openPaymentConfirmation,
+    pendingAuthSecret,
+    stripe,
+    totalPrice,
+    translate
+  ]);
+  const handleSubmit = useCallback(
+    async (formData) => {
+      if (pendingAuthSecret && activeSubscription?.date_cancellation) return handleReactivate();
+      const periodicity = billingPeriodToNumeric(billingPeriod ?? "monthly");
+      const periodLbl = getBillingPeriodSuffix(billingPeriod ?? "monthly", translate);
+      try {
+        let createdItem;
+        if (activeSubscription?.date_cancellation) {
+          const result = await createSubscriptionAsync({
+            id_product: activeSubscription.id_product,
+            id_plan: effectivePlanId,
+            type: "client",
+            payment_method: paymentMethodToNumeric(formData.paymentMethod),
+            periodicity,
+            ...appliedCouponId != null && { id_coupon: appliedCouponId },
+            ...formData.paymentMethod === "card" && formData.selectedCardId ? { id_card: formData.selectedCardId } : {},
+            plan_items: [
+              { id_addon: ADDON_IDS.AI, quantity: selectedCredit.credits },
+              ...buildDomainPlanExtras([...domainBuckets, ...zeroedOldDomainBuckets]),
+              { id_addon: ADDON_IDS.AB_TEST, quantity: abTestPayloadQuantity }
+            ]
+          });
+          createdItem = Array.isArray(result?.data) ? result.data[0] : result?.data;
+        } else {
+          const updateData = pendingAuthSecret && pendingUpdatePayloadRef.current ? pendingUpdatePayloadRef.current : {
+            id_plan: effectivePlanId,
+            periodicity,
+            enable_charge: true,
+            payment_method: paymentMethodToNumeric(formData.paymentMethod),
+            ...appliedCouponId != null && { id_coupon: appliedCouponId },
+            ...formData.paymentMethod === "card" && formData.selectedCardId ? { id_card: formData.selectedCardId } : {},
+            plan_extras: [
+              { id_addon: ADDON_IDS.AI, quantity: selectedCredit.credits },
+              ...buildDomainPlanExtras([...domainBuckets, ...zeroedOldDomainBuckets]),
+              { id_addon: ADDON_IDS.AB_TEST, quantity: abTestPayloadQuantity }
+            ]
+          };
+          pendingUpdatePayloadRef.current = updateData;
+          const result = await updatePlanAsync({
+            subscriptionId: activeSubscription.id,
+            data: updateData
+          });
+          createdItem = Array.isArray(result?.data) ? result.data[0] : result?.data;
+          pendingUpdatePayloadRef.current = null;
+        }
+        handleClose();
+        if (createdItem && isPendingPixCreateSubscriptionResponse(createdItem)) {
+          if (formData.paymentMethod !== "pix") {
+            toast.custom((toastId) => /* @__PURE__ */ jsx(
+              Toast,
+              {
+                variant: "error",
+                message: translate("common.account.workspace.subscription.changePlan.toasts.updateError"),
+                toastId
+              }
+            ));
+            return;
+          }
+          openPixPayment({
+            qrCode: createdItem.pix.qr_code ?? null,
+            expiresAt: createdItem.pix.expires_at ?? null,
+            correlationId: createdItem.pix.correlation_id,
+            payNowCents: readProrataValueCents(createdItem)
+          });
+          return;
+        }
+        if ((immediateCharge?.total ?? 0) <= 0) {
+          toast.custom((toastId) => /* @__PURE__ */ jsx(
+            Toast,
+            {
+              variant: "success",
+              message: translate("common.account.workspace.subscription.changePlan.toasts.planUpdated"),
+              toastId
+            }
+          ));
+          return;
+        }
+        if (formData.paymentMethod === "pix") {
+          toast.custom((toastId) => /* @__PURE__ */ jsx(
+            Toast,
+            {
+              variant: "error",
+              message: translate("common.account.workspace.subscription.changePlan.toasts.pixNotGenerated"),
+              toastId
+            }
+          ));
+          return;
+        }
+        if (formData.paymentMethod === "boleto") {
+          toast.custom((toastId) => /* @__PURE__ */ jsx(
+            Toast,
+            {
+              variant: "success",
+              message: translate("common.account.workspace.subscription.changePlan.toasts.boletoGenerated"),
+              toastId
+            }
+          ));
+          return;
+        }
+        openPaymentConfirmation({
+          planName: effectivePlan?.name,
+          total: totalPrice ?? 0,
+          periodLabel: periodLbl,
+          immediateChargeTotal: immediateCharge?.total ?? null
+        });
+      } catch (error) {
+        if (error instanceof PaymentAuthenticationError && error.clientSecret) {
+          setPendingAuthSecret(error.clientSecret);
+        }
+        const message = error instanceof Error ? error.message : translate("common.account.workspace.subscription.changePlan.toasts.updateError");
+        toast.custom((toastId) => /* @__PURE__ */ jsx(Toast, { variant: "error", message, toastId }));
+      }
+    },
+    [
+      pendingAuthSecret,
+      handleReactivate,
+      activeSubscription,
+      billingPeriod,
+      createSubscriptionAsync,
+      effectivePlanId,
+      effectivePlan,
+      totalPrice,
+      handleClose,
+      updatePlanAsync,
+      appliedCouponId,
+      selectedCredit,
+      domainBuckets,
+      zeroedOldDomainBuckets,
+      abTestPayloadQuantity,
+      immediateCharge,
+      openPixPayment,
+      openPaymentConfirmation,
+      translate
+    ]
+  );
+  return {
+    open,
+    isReactivation,
+    isDowngrade,
+    currentStep,
+    handleBack,
+    handleContinue,
+    handleClose,
+    form,
+    paymentMethod,
+    selectedCardId,
+    isSubmitting,
+    // Base do extrato do resumo: PRÉ-desconto de periodicidade — o extrato desconta periodicidade
+    // e cupom em linhas próprias, então usar o total líquido aqui subtrairia duas vezes.
+    newPlanPrice: targetPlan?.pricingByPeriod ? targetPlan.pricingByPeriod.monthly * periodMonths : !isReactivation && currentPlan?.value != null ? currentPlan.value * periodMonths : null,
+    // Total líquido do plano-alvo no período, para o card de comparação.
+    newPlanChargedPrice: targetPlan?.pricing ? targetPlan.pricing[periodPricingKey].charged : !isReactivation && currentPlan?.pricing ? currentPlan.pricing[periodPricingKey].charged : !isReactivation && currentPlan?.value != null ? currentPlan.value * periodMonths : null,
+    // Riscado do preview: `list` do MESMO período do charged, nunca a âncora mensal x meses.
+    newPlanListPrice: targetPlan?.pricing ? targetPlan.pricing[periodPricingKey].list : !isReactivation && currentPlan?.pricing ? currentPlan.pricing[periodPricingKey].list : null,
+    planName: isReactivation ? targetPlan?.name ?? null : effectivePlan?.name ?? null,
+    wlName,
+    cards,
+    resolvedAddonCardId,
+    activeCardIdAddon,
+    setActiveCardIdAddon,
+    selectedCreditIndex,
+    setSelectedCreditIndex,
+    selectedCredit,
+    aiCreditOptions,
+    domains,
+    minDomains,
+    domainsCountLoading,
+    planIncludedDomains,
+    extraDomains,
+    isAtMin,
+    hasDomainsAddon,
+    domainBuckets,
+    primaryBucket,
+    alternativeBuckets,
+    hasAlternativeBuckets,
+    canDecreaseTotal: totalDomains > minDomains,
+    handleAlternativeDecrease,
+    handleAlternativeIncrease,
+    domainPriceMonthly,
+    handleDecreaseDomains,
+    handleIncreaseDomains,
+    handleDomainsChange,
+    abTestEnabled,
+    setAbTestEnabled,
+    hasAbTestAddon,
+    abTestIncludedInPlan,
+    abTestPriceMonthly,
+    handleApplyCoupon,
+    handleRemoveCoupon,
+    handleOpenCouponDialog,
+    isCouponDialogOpen,
+    setIsCouponDialogOpen,
+    handleOpenPlansCatalog,
+    appliedCouponStripeData,
+    disabledBillingPeriods,
+    disabledPaymentMethods,
+    allowedBillingPeriod,
+    allowedPaymentMethod,
+    couponUnlocksAllMethods,
+    allowBoletoFromCurrentSubscription,
+    allowPixFromCurrentSubscription,
+    boletoAvailable,
+    pixAvailable,
+    paymentMethodFromSubscription,
+    hasChangedPaymentMethod,
+    appliedCouponCode,
+    isCalculating,
+    totalPrice,
+    discountAmount,
+    couponDiscountAmount,
+    billingPeriod,
+    modalBillingPeriod,
+    billingLabel,
+    billingLabelFull,
+    periodMonths,
+    periodLabel,
+    currentBillingPeriod,
+    currentPeriodLabel,
+    handleSubmit,
+    handleReactivate,
+    isReactivating,
+    hasPendingAuth: pendingAuthSecret !== null,
+    canReactivate: effectivePlanId != null,
+    requiresBillingData,
+    openBillingAddress,
+    contractingBillingPeriod: billingPeriod,
+    setContractingBillingPeriod,
+    calculatedPricing,
+    billingDiscounts,
+    firstPeriodPricingByPeriod,
+    planPricing: targetPlan?.pricing ?? null,
+    abTestDetailsOpen,
+    setAbTestDetailsOpen,
+    getPeriodicityLabel,
+    targetPlan,
+    immediateCharge,
+    calculatedPlanExtras: calculatedData?.plan_extras ?? [],
+    hasChanges,
+    formatCurrencyNumber
+  };
+}
+export {
+  ChangePlanProvider,
+  changePlanSchema,
+  useChangePlan,
+  useChangePlanLogic
+};
+//# sourceMappingURL=useChangePlanState.mjs.map