@blocklet/payment-react-headless 1.26.1 → 1.26.3

package/es/checkout/context/CheckoutProvider.js

@@ -28,11 +28,12 @@ export function CheckoutProvider({ sessionId, children }) {
   } = useCheckoutSession(sessionId);
   const session = sessionData?.checkoutSession;
   const effectiveSessionId = resolvedSessionId || sessionId;
-  const items = session?.line_items || [];
+  const items = useMemo(() => session?.line_items || [], [session?.line_items]);
   const isDonation = session?.submit_type === "donate";
   const sessionValue = useMemo(
     () => ({
       sessionData,
+      setSessionData,
       sessionId,
       effectiveSessionId,
       isLoading,
@@ -49,6 +50,7 @@ export function CheckoutProvider({ sessionId, children }) {
     }),
     [
       sessionData,
+      setSessionData,
       sessionId,
       effectiveSessionId,
       isLoading,
@@ -64,14 +66,18 @@ export function CheckoutProvider({ sessionId, children }) {
       pageInfo
     ]
   );
-  const paymentMethodHook = usePaymentMethodHook(sessionData, effectiveSessionId, refresh);
+  const paymentMethodHook = usePaymentMethodHook(sessionData, effectiveSessionId, refresh, setSessionData);
   const prevCurrencyRef = useRef(null);
   useEffect(() => {
     const currId = paymentMethodHook.currency?.id || null;
     if (!currId || !session || session.status === "complete") return;
     if (prevCurrencyRef.current === null || currId !== prevCurrencyRef.current) {
       prevCurrencyRef.current = currId;
-      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then(() => refresh(true));
+      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then((recalculated) => {
+        if (recalculated) {
+          refresh(true);
+        }
+      });
     }
   }, [paymentMethodHook.currency?.id, session?.id]);
   const paymentMethodValue = useMemo(
@@ -89,6 +95,7 @@ export function CheckoutProvider({ sessionId, children }) {
       setCurrency: paymentMethodHook.setCurrency,
       stripe: paymentMethodHook.stripe
     }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
     [
       paymentMethodHook.current,
       paymentMethodHook.currency,
@@ -114,7 +121,7 @@ export function CheckoutProvider({ sessionId, children }) {
   const mountedRef = useRef(true);
   const hasDynamicPricing = useMemo(() => checkHasDynamicPricing(items), [items]);
   const fetchRate = useMemoizedFn(async () => {
-    if (!effectiveSessionId || !hasDynamicPricing || paymentMethodHook.isStripe) {
+    if (!effectiveSessionId || !hasDynamicPricing || paymentMethodHook.isStripe || paymentMethodHook.switching) {
       setRateStatus(hasDynamicPricing ? "unavailable" : "available");
       if (paymentMethodHook.isStripe) {
         setExchangeRate(null);
@@ -148,17 +155,19 @@ export function CheckoutProvider({ sessionId, children }) {
   });
   useEffect(() => {
     mountedRef.current = true;
-    if (!hasDynamicPricing || paymentMethodHook.isStripe || !effectiveSessionId || session?.status === "complete") {
+    if (!hasDynamicPricing || paymentMethodHook.isStripe || paymentMethodHook.switching || !effectiveSessionId || session?.status === "complete") {
       if (paymentMethodHook.isStripe) {
         setExchangeRate(null);
         setRateProvider(null);
         setRateProviderDisplay(null);
         setRateFetchedAt(null);
       }
-      if (session?.status === "complete") {
-        setRateStatus("available");
-      } else {
-        setRateStatus(hasDynamicPricing ? "unavailable" : "available");
+      if (!paymentMethodHook.switching) {
+        if (session?.status === "complete") {
+          setRateStatus("available");
+        } else {
+          setRateStatus(hasDynamicPricing ? "unavailable" : "available");
+        }
       }
       return void 0;
     }
@@ -175,7 +184,14 @@ export function CheckoutProvider({ sessionId, children }) {
       if (intervalRef.current) clearInterval(intervalRef.current);
       document.removeEventListener("visibilitychange", handleVisibility);
     };
-  }, [hasDynamicPricing, paymentMethodHook.isStripe, effectiveSessionId, paymentMethodHook.currency?.id, session?.status]);
+  }, [
+    hasDynamicPricing,
+    paymentMethodHook.isStripe,
+    paymentMethodHook.switching,
+    effectiveSessionId,
+    paymentMethodHook.currency?.id,
+    session?.status
+  ]);
   const exchangeRateValue = useMemo(
     () => ({
       rate: exchangeRate,

package/es/checkout/context/SessionContext.d.ts

@@ -2,11 +2,13 @@ import type { TLineItemExpanded, TCheckoutSessionExpanded } from '@blocklet/paym
 import type { SessionData } from '../hooks/useCheckoutSession';
 export interface SessionContextValue {
     sessionData: SessionData | null;
+    /** Directly replace session data (e.g. using PUT response to skip redundant GET) */
+    setSessionData: (data: SessionData) => void;
     sessionId: string;
     effectiveSessionId: string;
     isLoading: boolean;
     error: string | null;
-    errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null;
+    errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | 'STOP_ACCEPTING_ORDERS' | null;
     refresh: (forceRefresh?: boolean) => Promise<void>;
     items: TLineItemExpanded[];
     session: TCheckoutSessionExpanded | null | undefined;

package/es/checkout/core/crossSell.d.ts

@@ -1,4 +1,5 @@
 import type { TCheckoutSessionExpanded, TPrice } from '@blocklet/payment-types';
-export declare function addCrossSellItem(sessionId: string, crossSellItemId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
-export declare function removeCrossSellItem(sessionId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
+import type { SessionData } from '../hooks/useCheckoutSession';
+export declare function addCrossSellItem(sessionId: string, crossSellItemId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>, sessionData?: SessionData | null, setSessionData?: (data: SessionData) => void): Promise<void>;
+export declare function removeCrossSellItem(sessionId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>, sessionData?: SessionData | null, setSessionData?: (data: SessionData) => void): Promise<void>;
 export declare function fetchCrossSellItem(sessionId: string): Promise<TPrice | null>;

package/es/checkout/core/crossSell.js

@@ -1,14 +1,30 @@
 import api, { API } from "../../shared/api.js";
 import { recalculatePromotionIfNeeded } from "./lineItems.js";
-export async function addCrossSellItem(sessionId, crossSellItemId, session, currencyId, refresh) {
-  await api.put(API.CROSS_SELL(sessionId), { to: crossSellItemId });
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+export async function addCrossSellItem(sessionId, crossSellItemId, session, currencyId, refresh, sessionData, setSessionData) {
+  const { data } = await api.put(API.CROSS_SELL(sessionId), { to: crossSellItemId });
+  let finalSession = data;
+  if (data.discounts?.length) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: void 0 });
+  } else {
+    await refresh(true);
+  }
 }
-export async function removeCrossSellItem(sessionId, session, currencyId, refresh) {
-  await api.delete(API.CROSS_SELL(sessionId));
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+export async function removeCrossSellItem(sessionId, session, currencyId, refresh, sessionData, setSessionData) {
+  const { data } = await api.delete(API.CROSS_SELL(sessionId));
+  let finalSession = data;
+  if (data.discounts?.length) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: void 0 });
+  } else {
+    await refresh(true);
+  }
 }
 const pendingFetches = /* @__PURE__ */ new Map();
 export function fetchCrossSellItem(sessionId) {

package/es/checkout/core/customerForm.js

@@ -32,12 +32,6 @@ export function buildFields(session) {
         required: true,
         group: "address"
       },
-      {
-        name: "billing_address.line2",
-        type: "text",
-        required: false,
-        group: "address"
-      },
       {
         name: "billing_address.city",
         type: "text",

package/es/checkout/core/lineItems.d.ts

@@ -1,7 +1,8 @@
 import type { TCheckoutSessionExpanded, TLineItemExpanded, TPrice } from '@blocklet/payment-types';
-export declare function recalculatePromotionIfNeeded(session: TCheckoutSessionExpanded | undefined | null, sessionId: string, currencyId: string | null | undefined): Promise<void>;
-export declare function adjustQuantity(sessionId: string, itemId: string, qty: number, currencyId: string | null | undefined, session: TCheckoutSessionExpanded | undefined | null, refresh: (force?: boolean) => Promise<void>): Promise<void>;
-export declare function performUpsell(sessionId: string, fromId: string, toId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
-export declare function performDownsell(sessionId: string, priceId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
-export declare function changeDonationAmount(sessionId: string, priceId: string, amount: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
+import type { SessionData } from '../hooks/useCheckoutSession';
+export declare function recalculatePromotionIfNeeded(session: TCheckoutSessionExpanded | undefined | null, sessionId: string, currencyId: string | null | undefined): Promise<TCheckoutSessionExpanded | null>;
+export declare function adjustQuantity(sessionId: string, itemId: string, qty: number, currencyId: string | null | undefined, session: TCheckoutSessionExpanded | undefined | null, refresh: (force?: boolean) => Promise<void>, sessionData?: SessionData | null, setSessionData?: (data: SessionData) => void): Promise<void>;
+export declare function performUpsell(sessionId: string, fromId: string, toId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>, sessionData?: SessionData | null, setSessionData?: (data: SessionData) => void): Promise<void>;
+export declare function performDownsell(sessionId: string, priceId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>, sessionData?: SessionData | null, setSessionData?: (data: SessionData) => void): Promise<void>;
+export declare function changeDonationAmount(sessionId: string, priceId: string, amount: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>, sessionData?: SessionData | null, setSessionData?: (data: SessionData) => void): Promise<void>;
 export declare function getCrossSellItem(items: TLineItemExpanded[]): TPrice | null;

package/es/checkout/core/lineItems.js

@@ -1,52 +1,83 @@
 import api, { API } from "../../shared/api.js";
 import { recalculatePromotion, hasAppliedDiscounts } from "./promotion.js";
 export async function recalculatePromotionIfNeeded(session, sessionId, currencyId) {
-  if (!hasAppliedDiscounts(session)) return;
+  if (!hasAppliedDiscounts(session)) return null;
   try {
-    await recalculatePromotion(sessionId, currencyId);
+    return await recalculatePromotion(sessionId, currencyId);
   } catch {
+    return null;
   }
 }
-export async function adjustQuantity(sessionId, itemId, qty, currencyId, session, refresh) {
-  await api.put(API.ADJUST_QUANTITY(sessionId), {
+export async function adjustQuantity(sessionId, itemId, qty, currencyId, session, refresh, sessionData, setSessionData) {
+  const { data } = await api.put(API.ADJUST_QUANTITY(sessionId), {
     itemId,
     quantity: qty,
     currency_id: currencyId
   });
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+  let finalSession = data;
+  if (data.discounts?.length || hasAppliedDiscounts(session)) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: void 0 });
+  } else {
+    await refresh(true);
+  }
 }
-export async function performUpsell(sessionId, fromId, toId, session, currencyId, refresh) {
+export async function performUpsell(sessionId, fromId, toId, session, currencyId, refresh, sessionData, setSessionData) {
   if ((session?.line_items?.length || 0) > 1) {
     try {
       await api.delete(API.CROSS_SELL(sessionId));
     } catch {
     }
   }
-  await api.put(API.UPSELL(sessionId), { from: fromId, to: toId });
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+  const { data } = await api.put(API.UPSELL(sessionId), { from: fromId, to: toId });
+  let finalSession = data;
+  if (data.discounts?.length || hasAppliedDiscounts(session)) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: void 0 });
+  } else {
+    await refresh(true);
+  }
 }
-export async function performDownsell(sessionId, priceId, session, currencyId, refresh) {
+export async function performDownsell(sessionId, priceId, session, currencyId, refresh, sessionData, setSessionData) {
   if ((session?.line_items?.length || 0) > 1) {
     try {
       await api.delete(API.CROSS_SELL(sessionId));
     } catch {
     }
   }
-  await api.put(API.DOWNSELL(sessionId), { from: priceId });
-  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
-  await refresh(true);
+  const { data } = await api.put(API.DOWNSELL(sessionId), { from: priceId });
+  let finalSession = data;
+  if (data.discounts?.length || hasAppliedDiscounts(session)) {
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: void 0 });
+  } else {
+    await refresh(true);
+  }
 }
-export async function changeDonationAmount(sessionId, priceId, amount, session, currencyId, refresh) {
+export async function changeDonationAmount(sessionId, priceId, amount, session, currencyId, refresh, sessionData, setSessionData) {
   const { data } = await api.put(API.CHANGE_AMOUNT(sessionId), {
     priceId,
     amount
   });
+  let finalSession = data;
   if (data?.discounts?.length) {
-    await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    const recalculated = await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+    if (recalculated) finalSession = recalculated;
+  }
+  if (sessionData && setSessionData) {
+    setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: void 0 });
+  } else {
+    await refresh(true);
   }
-  await refresh(true);
 }
 export function getCrossSellItem(items) {
   for (const item of items) {

package/es/checkout/core/paymentMethod.js

@@ -21,33 +21,41 @@ export function getCurrencyStorageKey(did) {
   return did ? `${CURRENCY_PREFERENCE_KEY}:${did}` : CURRENCY_PREFERENCE_KEY;
 }
 export function getInitialCurrencyId(session, methods) {
+  const availableCurrencyIds = new Set(
+    methods.flatMap((m) => (m.payment_currencies || []).map((c) => c.id)).filter(Boolean)
+  );
+  const isAvailable = (currencyId) => !!currencyId && availableCurrencyIds.has(currencyId);
+  if (session?.discounts?.length && isAvailable(session.currency_id)) {
+    return session.currency_id;
+  }
   if (typeof window !== "undefined") {
     try {
       const params = new URLSearchParams(window.location.search);
       const urlCurrency = params.get("currencyId") || params.get("currency_id");
-      if (urlCurrency) return urlCurrency;
+      if (isAvailable(urlCurrency)) return urlCurrency;
     } catch {
     }
     const user = session?.user;
     if (user && !hasDidWallet(user)) {
       const stripeMethod = methods.find((m) => m.type === "stripe");
       const stripeCurrency = stripeMethod?.payment_currencies?.[0];
-      if (stripeCurrency) return stripeCurrency.id;
+      if (isAvailable(stripeCurrency?.id)) return stripeCurrency?.id;
     }
     try {
       const did = session?.user?.did;
       const stored = localStorage.getItem(getCurrencyStorageKey(did));
-      if (stored) return stored;
+      if (isAvailable(stored)) return stored;
     } catch {
     }
   }
-  return session?.currency_id || null;
+  if (isAvailable(session?.currency_id)) {
+    return session?.currency_id;
+  }
+  return methods[0]?.payment_currencies?.[0]?.id || null;
 }
 export function findMethodAndCurrency(methods, currencyId) {
   if (!currencyId) {
-    const first2 = methods[0];
-    const firstCurrency = first2?.payment_currencies?.[0] || null;
-    return { method: first2 || null, currency: firstCurrency };
+    return { method: null, currency: null };
   }
   for (const method of methods) {
     for (const currency of method.payment_currencies || []) {

package/es/checkout/core/pricing.js

@@ -77,7 +77,6 @@ export function calculateAmounts(items, currency, session, exchangeRate, hasDyna
     exchangeRate: hasDynamicPricing ? exchangeRate : null
   });
   const subtotalBN = new BN(result.total);
-  const subtotalFormatted = formatDynamicPrice(fromUnitToToken(subtotalBN, currency.decimal), hasDynamicPricing);
   const discountBN = calculateCouponDiscount(items, currency, session, hasDynamicPricing, exchangeRate, trialing, false);
   const discount = discountBN.gt(new BN(0)) ? formatDynamicPrice(fromUnitToToken(discountBN.toString(), currency.decimal), hasDynamicPricing) : null;
   const taxAmount = session?.total_details?.amount_tax;
@@ -125,7 +124,7 @@ export function calculateAmounts(items, currency, session, exchangeRate, hasDyna
   const stakingFormatted = stakingBN.gt(new BN(0)) ? `${formatDynamicPrice(fromUnitToToken(stakingBN.toString(), currency.decimal), hasDynamicPricing)} ${currency.symbol}` : null;
   return {
     subtotal: `${displaySubtotalFormatted} ${currency.symbol}`,
-    paymentAmount: `${subtotalFormatted} ${currency.symbol}`,
+    paymentAmount: `${totalFormatted} ${currency.symbol}`,
     total: `${totalFormatted} ${currency.symbol}`,
     discount: discount ? `${discount} ${currency.symbol}` : null,
     tax,

package/es/checkout/core/promotion.d.ts

@@ -5,6 +5,6 @@ export declare function applyPromotionCode(sessionId: string, code: string, curr
     error?: string;
 }>;
 export declare function removePromotionCode(sessionId: string): Promise<void>;
-export declare function recalculatePromotion(sessionId: string, currencyId: string | null | undefined): Promise<void>;
+export declare function recalculatePromotion(sessionId: string, currencyId: string | null | undefined): Promise<TCheckoutSessionExpanded>;
 export declare function isPromotionActive(session: TCheckoutSessionExpanded | undefined | null): boolean;
 export declare function hasAppliedDiscounts(session: TCheckoutSessionExpanded | undefined | null): boolean;

package/es/checkout/core/promotion.js

@@ -26,9 +26,10 @@ export async function removePromotionCode(sessionId) {
   await api.delete(API.REMOVE_PROMOTION(sessionId));
 }
 export async function recalculatePromotion(sessionId, currencyId) {
-  await api.post(API.RECALCULATE_PROMOTION_SESSION(sessionId), {
+  const { data } = await api.post(API.RECALCULATE_PROMOTION_SESSION(sessionId), {
     currency_id: currencyId
   });
+  return data;
 }
 export function isPromotionActive(session) {
   return session?.allow_promotion_codes !== false;

package/es/checkout/hooks/useBillingInterval.js

@@ -6,20 +6,21 @@ import { usePaymentMethodContext } from "../context/PaymentMethodContext.js";
 import { parseBillingInterval } from "../core/billingInterval.js";
 import { performUpsell, performDownsell } from "../core/lineItems.js";
 export function useBillingInterval() {
-  const { items, session, effectiveSessionId, refresh } = useSessionContext();
+  const { items, session, effectiveSessionId, refresh, sessionData, setSessionData } = useSessionContext();
   const { currency } = usePaymentMethodContext();
   const currencyId = currency?.id || null;
   const [switching, setSwitching] = useState(false);
+  const [pendingInterval, setPendingInterval] = useState(null);
   const upsell = useMemoizedFn(async (fromId, toId) => {
     try {
-      await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+      await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err) {
       console.error("Failed to upsell:", getErrorMessage(err));
     }
   });
   const downsell = useMemoizedFn(async (priceId) => {
     try {
-      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh);
+      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err) {
       console.error("Failed to downsell:", getErrorMessage(err));
     }
@@ -28,12 +29,13 @@ export function useBillingInterval() {
     const parsed = parseBillingInterval(items);
     if (!parsed) return null;
     return {
-      current: parsed.current,
+      current: pendingInterval || parsed.current,
       available: parsed.available,
       switching,
       switch: async (interval) => {
         const target = parsed.available.find((a) => a.interval === interval);
         if (!target || switching) return;
+        setPendingInterval(interval);
         setSwitching(true);
         try {
           if (!parsed.firstItem.upsell_price_id && target.priceId) {
@@ -43,8 +45,9 @@ export function useBillingInterval() {
           }
         } finally {
           setSwitching(false);
+          setPendingInterval(null);
         }
       }
     };
-  }, [items, effectiveSessionId, switching]);
+  }, [items, effectiveSessionId, switching, pendingInterval]);
 }

package/es/checkout/hooks/useCheckout.js

@@ -22,6 +22,7 @@ export function useCheckout(sessionId) {
     error,
     errorCode,
     refresh,
+    setSessionData,
     sessionData,
     resolvedSessionId,
     vendorCount,
@@ -31,14 +32,15 @@ export function useCheckout(sessionId) {
   } = useCheckoutSession(sessionId);
   const session = sessionData?.checkoutSession;
   const effectiveSessionId = resolvedSessionId || sessionId;
-  const paymentMethodHook = usePaymentMethod(sessionData, effectiveSessionId, refresh);
+  const paymentMethodHook = usePaymentMethod(sessionData, effectiveSessionId, refresh, setSessionData);
   const pricingHook = usePricing(
     sessionData,
     effectiveSessionId,
     paymentMethodHook.currency,
     paymentMethodHook.isStripe,
     refresh,
-    paymentMethodHook.current?.type || null
+    paymentMethodHook.current?.type || null,
+    paymentMethodHook.switching
   );
   const formHook = useCustomerForm(
     sessionData,
@@ -57,34 +59,38 @@ export function useCheckout(sessionId) {
     formHook.validate,
     refresh
   );
-  const items = session?.line_items || [];
+  const items = useMemo(() => session?.line_items || [], [session?.line_items]);
   const currencyId = paymentMethodHook.currency?.id || null;
   const prevCurrencyRef = useRef(null);
   useEffect(() => {
     const currId = paymentMethodHook.currency?.id || null;
-    if (!currId || !session) return;
+    if (!currId || !session || session.status === "complete") return;
     if (prevCurrencyRef.current === null || currId !== prevCurrencyRef.current) {
       prevCurrencyRef.current = currId;
-      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then(() => refresh(true));
+      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then((recalculated) => {
+        if (recalculated) {
+          refresh(true);
+        }
+      });
     }
   }, [paymentMethodHook.currency?.id, session?.id]);
   const updateQuantity = useMemoizedFn(async (itemId, qty) => {
     try {
-      await adjustQuantity(effectiveSessionId, itemId, qty, currencyId, session, refresh);
+      await adjustQuantity(effectiveSessionId, itemId, qty, currencyId, session, refresh, sessionData, setSessionData);
     } catch (err) {
       console.error("Failed to update quantity:", getErrorMessage(err));
     }
   });
   const upsell = useMemoizedFn(async (fromId, toId) => {
     try {
-      await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+      await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err) {
       console.error("Failed to upsell:", getErrorMessage(err));
     }
   });
   const downsell = useMemoizedFn(async (priceId) => {
     try {
-      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh);
+      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err) {
       console.error("Failed to downsell:", getErrorMessage(err));
     }
@@ -109,14 +115,14 @@ export function useCheckout(sessionId) {
   const addCrossSell = useMemoizedFn(async () => {
     if (!crossSellItem) return;
     try {
-      await addCrossSellItem(effectiveSessionId, crossSellItem.id, session, currencyId, refresh);
+      await addCrossSellItem(effectiveSessionId, crossSellItem.id, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err) {
       console.error("Failed to add cross-sell:", getErrorMessage(err));
     }
   });
   const removeCrossSell = useMemoizedFn(async () => {
     try {
-      await removeCrossSellItem(effectiveSessionId, session, currencyId, refresh);
+      await removeCrossSellItem(effectiveSessionId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err) {
       console.error("Failed to remove cross-sell:", getErrorMessage(err));
     }
@@ -141,7 +147,7 @@ export function useCheckout(sessionId) {
   const setDonationAmount = useMemoizedFn(async (priceId, amount) => {
     if (!isDonation) return;
     try {
-      await changeDonationAmount(effectiveSessionId, priceId, amount, session, currencyId, refresh);
+      await changeDonationAmount(effectiveSessionId, priceId, amount, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err) {
       console.error("Failed to change amount:", getErrorMessage(err));
     }

package/es/checkout/hooks/useCheckoutSession.d.ts

@@ -18,8 +18,8 @@ export interface SessionData {
 export interface UseCheckoutSessionReturn {
     isLoading: boolean;
     error: string | null;
-    /** Error code for structured error handling: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null */
-    errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null;
+    /** Error code for structured error handling */
+    errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | 'STOP_ACCEPTING_ORDERS' | null;
     refresh: (forceRefresh?: boolean) => Promise<void>;
     /** Directly update session data (e.g. after completion polling returns fresh data) */
     setSessionData: (data: SessionData) => void;

package/es/checkout/hooks/useCheckoutSession.js

@@ -54,6 +54,11 @@ export function useCheckoutSession(sessionId) {
           return;
         }
       }
+      if (data?.stopAcceptingOrders && cs?.status !== "complete") {
+        setError("STOP_ACCEPTING_ORDERS");
+        setIsLoading(false);
+        return;
+      }
       setSessionData(data);
       setIsLoading(false);
     } catch (err) {
@@ -87,6 +92,8 @@ export function useCheckoutSession(sessionId) {
     errorCode = "SESSION_EXPIRED";
   } else if (error === "EMPTY_LINE_ITEMS") {
     errorCode = "EMPTY_LINE_ITEMS";
+  } else if (error === "STOP_ACCEPTING_ORDERS") {
+    errorCode = "STOP_ACCEPTING_ORDERS";
   }
   const vendorCount = session?.line_items?.reduce((count, item) => {
     return count + (item?.price?.product?.vendor_config?.length || 0);

package/es/checkout/hooks/useCheckoutStatus.d.ts

@@ -1,7 +1,7 @@
 export interface UseCheckoutStatusReturn {
     isLoading: boolean;
     error: string | null;
-    errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null;
+    errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | 'STOP_ACCEPTING_ORDERS' | null;
     canSubmit: boolean;
     isCompleted: boolean;
     isDonation: boolean;

package/es/checkout/hooks/useCrossSell.js

@@ -6,7 +6,7 @@ import { usePaymentMethodContext } from "../context/PaymentMethodContext.js";
 import { getCrossSellItem } from "../core/lineItems.js";
 import { addCrossSellItem, removeCrossSellItem, fetchCrossSellItem } from "../core/crossSell.js";
 export function useCrossSell() {
-  const { items, session, effectiveSessionId, refresh } = useSessionContext();
+  const { items, session, effectiveSessionId, refresh, sessionData, setSessionData } = useSessionContext();
   const { currency } = usePaymentMethodContext();
   const currencyId = currency?.id || null;
   const embeddedItem = useMemo(() => getCrossSellItem(items), [items]);
@@ -40,7 +40,15 @@ export function useCrossSell() {
     const crossSellItemPrice = getCrossSellItem(items);
     if (!crossSellItemPrice) return;
     try {
-      await addCrossSellItem(effectiveSessionId, crossSellItemPrice.id, session, currencyId, refresh);
+      await addCrossSellItem(
+        effectiveSessionId,
+        crossSellItemPrice.id,
+        session,
+        currencyId,
+        refresh,
+        sessionData,
+        setSessionData
+      );
     } catch (err) {
       console.error("Failed to add cross-sell:", getErrorMessage(err));
     }
@@ -48,7 +56,7 @@ export function useCrossSell() {
   const remove = useMemoizedFn(async () => {
     if (session?.status === "complete") return;
     try {
-      await removeCrossSellItem(effectiveSessionId, session, currencyId, refresh);
+      await removeCrossSellItem(effectiveSessionId, session, currencyId, refresh, sessionData, setSessionData);
     } catch (err) {
       console.error("Failed to remove cross-sell:", getErrorMessage(err));
     }

package/es/checkout/hooks/useCustomerForm.d.ts

@@ -7,7 +7,11 @@ export interface UseCustomerFormReturn {
     errors: Partial<Record<string, string>>;
     touched: Record<string, boolean>;
     validate: () => Promise<boolean>;
+    /** Silent validation — returns valid/invalid without setting error messages on the form */
+    checkValid: () => Promise<boolean>;
     validateField: (field: string) => Promise<void>;
+    /** Whether customer info has been prefetched from backend */
+    prefetched: boolean;
     /** Re-fetch customer info from backend and update form values (e.g. after login) */
     refetchCustomer: () => Promise<void>;
 }

package/es/checkout/hooks/useCustomerForm.js

@@ -67,6 +67,10 @@ export function useCustomerForm(sessionData, currencyId, methodId) {
     setErrors(result.errors);
     return result.valid;
   });
+  const checkValid = useMemoizedFn(async () => {
+    const result = await validateForm(values, getValidateOptions());
+    return result.valid;
+  });
   const validateField = useMemoizedFn(async (field) => {
     const result = await validateForm(values, getValidateOptions());
     setErrors((prev) => {
@@ -110,7 +114,9 @@ export function useCustomerForm(sessionData, currencyId, methodId) {
     errors,
     touched,
     validate,
+    checkValid,
     validateField,
+    prefetched,
     refetchCustomer
   };
 }