@greatapps/common 1.1.790 → 1.1.792

package/src/components/account/sections/subscription/change-plan/useChangePlanState.tsx

@@ -0,0 +1,1158 @@
+'use client';
+
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+  type ChangeEvent,
+} 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 type { CouponStripeData } from '../../../../../modules/coupons/types/coupon.type';
+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 type { BillingPeriod } from '../../../../../modules/subscriptions/types/billing-period.type';
+import type { UpdateSubscriptionPlanRequest } from '../../../../../modules/subscriptions/types/calculate-subscription.type';
+import {
+  getAddonBuckets,
+  buildDomainPlanExtras,
+  buildZeroedOldBuckets,
+  type AddonBucket,
+} from '../../../../../modules/subscriptions/utils/addon-buckets';
+import {
+  getFirstPeriodPricing,
+  type FirstPeriodPricing,
+} 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';
+
+/** Mínimo de domínios que qualquer plano inclui. */
+const MIN_DOMAINS = 1;
+
+export const changePlanSchema = z.object({
+  paymentMethod: z.enum(['card', 'boleto', 'pix']),
+  selectedCardId: z.string(),
+  selectedReason: z.string(),
+  reasonText: z.string(),
+});
+
+export type ChangePlanFormData = z.infer<typeof changePlanSchema>;
+
+type ChangePlanState = ReturnType<typeof useChangePlanLogic>;
+
+const ChangePlanContext = createContext<ChangePlanState | null>(null);
+
+export const ChangePlanProvider = ChangePlanContext.Provider;
+
+export function useChangePlan() {
+  const context = useContext(ChangePlanContext);
+  if (!context) throw new Error('useChangePlan precisa estar dentro de ChangePlanProvider');
+  return context;
+}
+
+/** Delta de pró-rata (centavos) do pix recorrente — resposta passthrough, leitura defensiva. */
+function readProrataValueCents(response: unknown): number | null {
+  const value = (response as { prorata_value_cents?: unknown }).prorata_value_cents;
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+const paymentMethodToNumeric = (method: 'card' | 'boleto' | 'pix') =>
+  method === 'card' ? 1 : method === 'boleto' ? 2 : 3;
+
+export 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 ?? undefined;
+  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<Record<string, number>>({});
+  const [abTestEnabled, setAbTestEnabled] = useState(false);
+  const [appliedCouponId, setAppliedCouponId] = useState<number | null>(null);
+  const [appliedCouponCode, setAppliedCouponCode] = useState<string | null>(null);
+  const [appliedCouponStripeData, setAppliedCouponStripeData] = useState<CouponStripeData | null>(null);
+  const [activeCardIdAddon, setActiveCardIdAddon] = useState('');
+  const [abTestDetailsOpen, setAbTestDetailsOpen] = useState(false);
+  const [isCouponDialogOpen, setIsCouponDialogOpen] = useState(false);
+  const [isReactivating, setIsReactivating] = useState(false);
+  /**
+   * Assinatura criada que ficou esperando o 3DS. Enquanto existir, o submit re-autentica ESTA
+   * cobrança em vez de criar outra — sem isso, quem erra a autenticação e tenta de novo termina
+   * com duas assinaturas.
+   */
+  const [pendingAuthSecret, setPendingAuthSecret] = useState<string | null>(null);
+  const pendingUpdatePayloadRef = useRef<UpdateSubscriptionPlanRequest | null>(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';
+  // Reativar pelo card não escolhe período (herda o da assinatura); vindo da vitrine, o período
+  // escolhido lá manda — inclusive na contratação, que reusa este mesmo fluxo.
+  const requestedBillingPeriod: BillingPeriod = data?.billingPeriod ?? subscriptionBillingPeriod;
+  // Só a contratação troca de período aqui dentro: na troca de plano o período já veio decidido
+  // pela vitrine, e na gestão de adicionais ele é o da assinatura corrente.
+  const [contractingBillingPeriod, setContractingBillingPeriod] = useState<BillingPeriod | null>(null);
+  const billingPeriod: BillingPeriod =
+    isReactivation && contractingBillingPeriod ? contractingBillingPeriod : requestedBillingPeriod;
+  const modalBillingPeriod: BillingPeriod = 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))
+      : undefined;
+
+  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);
+
+  // A/B incluso no plano (item com value 0) trava o toggle; só o A/B avulso pago é gerenciável.
+  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,
+  });
+
+  // Backend normalizado: `value` de plano e de assinatura é sempre mensal por unidade.
+  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);
+
+  // A/B incluso nunca é zerado no payload; fora disso segue o toggle.
+  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
+  );
+
+  // Reativação e troca de plano colapsam tudo no preço do plano novo.
+  const collapseToSingleBucket = isReactivation || !!targetPlan;
+  const primaryBucketPrice = planDomainPrice;
+  const domainBuckets = getAddonBuckets(
+    ADDON_IDS.DOMAINS,
+    collapseToSingleBucket ? [] : subscriptionItems,
+    primaryBucketPrice,
+    bucketEdits
+  );
+  // Troca de plano precisa zerar explicitamente os itens antigos em outros preços.
+  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;
+
+  // Piso: nunca abaixo do incluso no plano nem dos domínios já registrados.
+  const minDomains = registeredDomainsLoaded
+    ? Math.max(planIncludedDomains, registeredDomains)
+    : planIncludedDomains;
+  const domainsCountLoading = hasDomainsAddon && !registeredDomainsLoaded;
+  const isAtMin = totalDomains <= minDomains || primaryBucket.quantity <= 0;
+  const extraDomains = totalExtras;
+
+  const paymentMethodFromSubscription: 'card' | 'boleto' | 'pix' =
+    activeSubscription?.payment_method === 2
+      ? 'boleto'
+      : activeSubscription?.payment_method === 3
+        ? 'pix'
+        : 'card';
+
+  const form = useForm<ChangePlanFormData>({
+    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;
+
+  // Assinatura que já é boleto/pix mantém o método enquanto só gerencia adicionais.
+  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]);
+
+  // Volta para cartão quando o método escolhido deixa de ser permitido no contexto atual.
+  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) {
+        // Começa com o mínimo de extras que cobre os domínios em uso no plano novo.
+        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 }));
+        }
+      }
+    }
+
+    // Só liga o A/B se o plano efetivo suporta — item remanescente de downgrade não conta.
+    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);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+    open,
+    activeSubscription,
+    effectivePlan,
+    registeredDomainsLoaded,
+    hasDomainsAddon,
+    minDomains,
+    currentSubscriptionDomains,
+    data,
+    subscriptionCouponId,
+  ]);
+
+  // O cupom da assinatura pode chegar depois da inicialização.
+  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,
+  ]);
+
+  // Cartão default: espera a assinatura resolver para sincronizar com o cartão dela.
+  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 subscriptionCardId =
+      activeSubscription?.id_card != null ? String(activeSubscription.id_card) : null;
+    const subscriptionCard = subscriptionCardId
+      ? cards.find((card) => card.id.toString() === subscriptionCardId)
+      : undefined;
+    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;
+
+  // Boleto e pix emitem nota: sem cadastro fiscal completo o backend recusa a cobrança, então
+  // o passo de pagamento manda completar antes de deixar contratar. Só vale com a conta já
+  // carregada (senão travaria durante o loading) e brasileira — o formulário pede CPF/CNPJ e
+  // CEP, que um cliente de fora não tem como fornecer.
+  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;
+
+  // Totais por período para o seletor da contratação: o mesmo calculate já devolve os dois.
+  const calculatedPricing = calculatedData
+    ? { monthly: calculatedData.month, annual: calculatedData.year }
+    : null;
+  // Percentual EFETIVO por período (periodicidade + cupom, compostos pelo backend).
+  const billingDiscounts = {
+    monthly: getEffectiveDiscountPercent(calculatedData, 'monthly'),
+    annual: getEffectiveDiscountPercent(calculatedData, 'annual'),
+  };
+  // Split "1º período × depois" por período — null onde o cupom não desconta.
+  const firstPeriodPricingByPeriod: {
+    monthly: FirstPeriodPricing | null;
+    annual: FirstPeriodPricing | null;
+  } | null = 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: ChangeEvent<HTMLInputElement>) => {
+      const requested = Number.parseInt(event.target.value, 10);
+      if (Number.isNaN(requested)) return;
+
+      // O input mostra o TOTAL (incluso + primary); converte para a quantidade do primary.
+      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: AddonBucket) => {
+      if (bucket.quantity <= 0) return;
+      if (totalDomains - 1 < minDomains) return;
+      setBucketEdits((previous) => ({ ...previous, [bucket.key]: bucket.quantity - 1 }));
+    },
+    [totalDomains, minDomains]
+  );
+
+  const handleAlternativeIncrease = useCallback((bucket: AddonBucket) => {
+    if (bucket.quantity >= bucket.originalQuantity) return;
+    setBucketEdits((previous) => ({ ...previous, [bucket.key]: bucket.quantity + 1 }));
+  }, []);
+
+  const handleApplyCoupon = useCallback(
+    (coupon: { id: number; code: string; stripeData?: CouponStripeData | null }) => {
+      const stripeData = coupon.stripeData ?? null;
+
+      if (!isCouponApplicableToPlan(stripeData, effectivePlanId)) {
+        toast.custom((toastId) => (
+          <Toast
+            variant="error"
+            message={translate('common.account.workspace.subscription.changePlan.toasts.couponNotValidForPlan', {
+              code: coupon.code,
+            })}
+            toastId={toastId}
+          />
+        ));
+        return;
+      }
+
+      const { disabledBillingPeriods: blockedPeriods } = getCouponRestrictions(stripeData);
+      if (blockedPeriods.includes(billingPeriod)) {
+        toast.custom((toastId) => (
+          <Toast
+            variant="error"
+            message={translate('common.account.workspace.subscription.changePlan.toasts.couponNotValidForPeriod', {
+              code: coupon.code,
+            })}
+            toastId={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) => (
+      <Toast
+        variant="warning"
+        message={translate('common.account.workspace.subscription.changePlan.toasts.couponRemovedInvalidPlan', {
+          code: code ?? '',
+        })}
+        toastId={toastId}
+      />
+    ));
+  }, [effectivePlanId, appliedCouponStripeData, appliedCouponCode, handleRemoveCoupon, translate]);
+
+  useEffect(() => {
+    if (!appliedCouponStripeData) return;
+    if (!disabledBillingPeriods.includes(billingPeriod)) return;
+
+    const code = appliedCouponCode;
+    handleRemoveCoupon();
+    toast.custom((toastId) => (
+      <Toast
+        variant="warning"
+        message={translate('common.account.workspace.subscription.changePlan.toasts.couponRemovedInvalidPeriod', {
+          code: code ?? '',
+        })}
+        toastId={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 () => {
+    // Sem plano-alvo é a reativação do mesmo plano; com plano-alvo (veio da vitrine) contrata o
+    // escolhido — nos dois casos a assinatura é criada do zero.
+    const reactivationPlanId = effectivePlanId ?? activeSubscription?.id_plan;
+    if (!reactivationPlanId) return;
+
+    // Assinatura já criada esperando o 3DS: reautentica ELA em vez de contratar de novo.
+    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) => (
+          <Toast
+            variant="error"
+            message={
+              error instanceof Error ? error.message : translate('common.payment.authFailed')
+            }
+            toastId={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) => (
+            <Toast
+              variant="error"
+              message={translate('common.account.workspace.subscription.changePlan.toasts.pixNotGenerated')}
+              toastId={toastId}
+            />
+          ));
+        }
+        return;
+      }
+
+      // Boleto recém-gerado: abre a linha digitável na hora, sem mandar o cliente procurar na
+      // lista de cobranças.
+      if (paymentMethod === 'boleto') {
+        const createdId = (created as { id?: string | number } | undefined)?.id;
+        if (createdId != null) {
+          openBoletoGenerated({ subscriptionId: createdId });
+          return;
+        }
+      }
+
+      toast.custom((toastId) => (
+        <Toast
+          variant="success"
+          message={translate('common.account.workspace.subscription.changePlan.toasts.planReactivated', {
+            planName: targetPlan?.name ?? resolveSubscriptionPlanName(activeSubscription, translate),
+          })}
+          toastId={toastId}
+        />
+      ));
+    } catch (error) {
+      // 3DS recusado com a assinatura já criada: guarda o segredo para a próxima tentativa
+      // autenticar a mesma cobrança.
+      if (error instanceof PaymentAuthenticationError && error.clientSecret) {
+        setPendingAuthSecret(error.clientSecret);
+      }
+      toast.custom((toastId) => (
+        <Toast
+          variant="error"
+          message={
+            error instanceof PaymentAuthenticationError
+              ? error.message
+              : translate('common.account.workspace.subscription.changePlan.toasts.reactivateError')
+          }
+          toastId={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: ChangePlanFormData) => {
+      if (pendingAuthSecret && activeSubscription?.date_cancellation) return handleReactivate();
+
+      const periodicity = billingPeriodToNumeric(billingPeriod ?? 'monthly');
+      const periodLbl = getBillingPeriodSuffix(billingPeriod ?? 'monthly', translate);
+
+      try {
+        let createdItem: unknown;
+
+        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: UpdateSubscriptionPlanRequest =
+            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();
+
+        // Pix pendente tem precedência: o backend devolve a estrutura quando precisa gerar o QR.
+        if (createdItem && isPendingPixCreateSubscriptionResponse(createdItem)) {
+          if (formData.paymentMethod !== 'pix') {
+            // Pix pendente com cartão/boleto significa que o plano não foi aplicado.
+            toast.custom((toastId) => (
+              <Toast
+                variant="error"
+                message={translate('common.account.workspace.subscription.changePlan.toasts.updateError')}
+                toastId={toastId}
+              />
+            ));
+            return;
+          }
+
+          openPixPayment({
+            qrCode: createdItem.pix.qr_code ?? null,
+            expiresAt: createdItem.pix.expires_at ?? null,
+            correlationId: createdItem.pix.correlation_id,
+            payNowCents: readProrataValueCents(createdItem),
+          });
+          return;
+        }
+
+        // Sem cobrança imediata (downgrade/alteração agendada): só confirma a atualização.
+        if ((immediateCharge?.total ?? 0) <= 0) {
+          toast.custom((toastId) => (
+            <Toast
+              variant="success"
+              message={translate('common.account.workspace.subscription.changePlan.toasts.planUpdated')}
+              toastId={toastId}
+            />
+          ));
+          return;
+        }
+
+        if (formData.paymentMethod === 'pix') {
+          toast.custom((toastId) => (
+            <Toast
+              variant="error"
+              message={translate('common.account.workspace.subscription.changePlan.toasts.pixNotGenerated')}
+              toastId={toastId}
+            />
+          ));
+          return;
+        }
+
+        if (formData.paymentMethod === 'boleto') {
+          // O boleto sai na fatura gerada — o cliente abre os dados pela lista de cobranças.
+          toast.custom((toastId) => (
+            <Toast
+              variant="success"
+              message={translate('common.account.workspace.subscription.changePlan.toasts.boletoGenerated')}
+              toastId={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) => <Toast variant="error" message={message} toastId={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,
+  };
+}