@blocklet/payment-react-headless 1.26.0 → 1.26.2

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 && sessionData) {
+          setSessionData({ ...sessionData, checkoutSession: recalculated, quotes: void 0 });
+        }
+      });
     }
   }, [paymentMethodHook.currency?.id, session?.id]);
   const paymentMethodValue = useMemo(
@@ -175,7 +181,13 @@ 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,
+    effectiveSessionId,
+    paymentMethodHook.currency?.id,
+    session?.status
+  ]);
   const exchangeRateValue = useMemo(
     () => ({
       rate: exchangeRate,

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

@@ -2,6 +2,8 @@ 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;

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/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/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,7 +32,7 @@ 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,
@@ -57,7 +58,7 @@ 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(() => {
@@ -65,26 +66,30 @@ export function useCheckout(sessionId) {
     if (!currId || !session) 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 && sessionData) {
+          setSessionData({ ...sessionData, checkoutSession: recalculated, quotes: void 0 });
+        }
+      });
     }
   }, [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 +114,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 +146,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/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/useLineItems.js

@@ -12,12 +12,13 @@ import {
 } from "../core/lineItems.js";
 import { addCrossSellItem, removeCrossSellItem, fetchCrossSellItem } from "../core/crossSell.js";
 export function useLineItems() {
-  const { items, session, effectiveSessionId, isDonation, refresh } = useSessionContext();
+  const { items, session, effectiveSessionId, isDonation, refresh, sessionData, setSessionData } = useSessionContext();
   const { currency } = usePaymentMethodContext();
   const currencyId = currency?.id || null;
   const defaultQtyApplied = useRef(false);
   useEffect(() => {
-    if (defaultQtyApplied.current || !effectiveSessionId || !items.length || !currencyId || session?.status === "complete") return;
+    if (defaultQtyApplied.current || !effectiveSessionId || !items.length || !currencyId || session?.status === "complete")
+      return;
     try {
       const params = new URLSearchParams(window.location.search);
       for (const item of items) {
@@ -26,7 +27,16 @@ export function useLineItems() {
           const qty = Math.max(1, parseInt(qtyStr, 10));
           if (Number.isFinite(qty) && qty !== item.quantity) {
             defaultQtyApplied.current = true;
-            adjustQuantity(effectiveSessionId, item.price_id, qty, currencyId, session, refresh);
+            adjustQuantity(
+              effectiveSessionId,
+              item.price_id,
+              qty,
+              currencyId,
+              session,
+              refresh,
+              sessionData,
+              setSessionData
+            );
             break;
           }
         }
@@ -37,18 +47,18 @@ export function useLineItems() {
   const updateQuantity = useMemoizedFn(async (itemId, qty) => {
     if (session?.status === "complete") return;
     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) => {
     if (session?.status === "complete") return;
-    await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+    await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh, sessionData, setSessionData);
   });
   const downsell = useMemoizedFn(async (priceId) => {
     if (session?.status === "complete") return;
-    await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh);
+    await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh, sessionData, setSessionData);
   });
   const embeddedCrossSellItem = useMemo(() => getCrossSellItem(items), [items]);
   const [fetchedCrossSellItem, setFetchedCrossSellItem] = useState(null);
@@ -80,7 +90,15 @@ export function useLineItems() {
     if (session?.status === "complete") return;
     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));
     }
@@ -88,7 +106,7 @@ export function useLineItems() {
   const removeCrossSell = 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));
     }
@@ -97,7 +115,16 @@ export function useLineItems() {
     if (session?.status === "complete") return;
     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/usePaymentMethod.d.ts

@@ -23,4 +23,4 @@ export interface UsePaymentMethodReturn {
         status: 'idle' | 'ready' | 'processing' | 'succeeded' | 'failed';
     } | null;
 }
-export declare function usePaymentMethod(sessionData: SessionData | null, sessionId: string, refreshSession: (force?: boolean) => Promise<void>): UsePaymentMethodReturn;
+export declare function usePaymentMethod(sessionData: SessionData | null, sessionId: string, refreshSession: (force?: boolean) => Promise<void>, setSessionData?: (data: SessionData) => void): UsePaymentMethodReturn;

package/es/checkout/hooks/usePaymentMethod.js

@@ -9,8 +9,9 @@ import {
   findMethodAndCurrency,
   buildPaymentTypes
 } from "../core/paymentMethod.js";
-export function usePaymentMethod(sessionData, sessionId, refreshSession) {
-  const methods = sessionData?.paymentMethods || [];
+import { recalculatePromotionIfNeeded } from "../core/lineItems.js";
+export function usePaymentMethod(sessionData, sessionId, refreshSession, setSessionData) {
+  const methods = useMemo(() => sessionData?.paymentMethods || [], [sessionData?.paymentMethods]);
   const session = sessionData?.checkoutSession;
   const [currencyId, setCurrencyId] = useState(() => getInitialCurrencyId(session, methods));
   const [switching, setSwitching] = useState(false);
@@ -43,7 +44,7 @@ export function usePaymentMethod(sessionData, sessionId, refreshSession) {
     if (!method || !sessionId) return;
     setSwitching(true);
     try {
-      await api.put(API.SWITCH_CURRENCY(sessionId), {
+      const { data } = await api.put(API.SWITCH_CURRENCY(sessionId), {
         currency_id: newCurrencyId,
         payment_method_id: method.id
       });
@@ -55,7 +56,16 @@ export function usePaymentMethod(sessionData, sessionId, refreshSession) {
         );
       } catch {
       }
-      await refreshSession(true);
+      let finalSession = data;
+      if (data.discounts?.length) {
+        const recalculated = await recalculatePromotionIfNeeded(session, sessionId, newCurrencyId);
+        if (recalculated) finalSession = recalculated;
+      }
+      if (sessionData && setSessionData) {
+        setSessionData({ ...sessionData, checkoutSession: finalSession, quotes: void 0 });
+      } else {
+        await refreshSession(true);
+      }
     } catch (err) {
       console.error("Failed to switch currency:", getErrorMessage(err));
       if (session?.currency_id) {

package/es/checkout/hooks/useUpsell.js

@@ -4,19 +4,19 @@ import { useSessionContext } from "../context/SessionContext.js";
 import { usePaymentMethodContext } from "../context/PaymentMethodContext.js";
 import { performUpsell, performDownsell } from "../core/lineItems.js";
 export function useUpsell() {
-  const { session, effectiveSessionId, refresh } = useSessionContext();
+  const { session, effectiveSessionId, refresh, sessionData, setSessionData } = useSessionContext();
   const { currency } = usePaymentMethodContext();
   const currencyId = currency?.id || 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));
     }

package/lib/checkout/context/CheckoutProvider.js

@@ -37,10 +37,11 @@ function CheckoutProvider({
   } = (0, _useCheckoutSession.useCheckoutSession)(sessionId);
   const session = sessionData?.checkoutSession;
   const effectiveSessionId = resolvedSessionId || sessionId;
-  const items = session?.line_items || [];
+  const items = (0, _react.useMemo)(() => session?.line_items || [], [session?.line_items]);
   const isDonation = session?.submit_type === "donate";
   const sessionValue = (0, _react.useMemo)(() => ({
     sessionData,
+    setSessionData,
     sessionId,
     effectiveSessionId,
     isLoading,
@@ -54,15 +55,23 @@ function CheckoutProvider({
     product,
     subscription,
     pageInfo
-  }), [sessionData, sessionId, effectiveSessionId, isLoading, error, errorCode, refresh, items, session, isDonation, vendorCount, product, subscription, pageInfo]);
-  const paymentMethodHook = (0, _usePaymentMethod.usePaymentMethod)(sessionData, effectiveSessionId, refresh);
+  }), [sessionData, setSessionData, sessionId, effectiveSessionId, isLoading, error, errorCode, refresh, items, session, isDonation, vendorCount, product, subscription, pageInfo]);
+  const paymentMethodHook = (0, _usePaymentMethod.usePaymentMethod)(sessionData, effectiveSessionId, refresh, setSessionData);
   const prevCurrencyRef = (0, _react.useRef)(null);
   (0, _react.useEffect)(() => {
     const currId = paymentMethodHook.currency?.id || null;
     if (!currId || !session || session.status === "complete") return;
     if (prevCurrencyRef.current === null || currId !== prevCurrencyRef.current) {
       prevCurrencyRef.current = currId;
-      (0, _lineItems.recalculatePromotionIfNeeded)(session, effectiveSessionId, currId).then(() => refresh(true));
+      (0, _lineItems.recalculatePromotionIfNeeded)(session, effectiveSessionId, currId).then(recalculated => {
+        if (recalculated && sessionData) {
+          setSessionData({
+            ...sessionData,
+            checkoutSession: recalculated,
+            quotes: void 0
+          });
+        }
+      });
     }
   }, [paymentMethodHook.currency?.id, session?.id]);
   const paymentMethodValue = (0, _react.useMemo)(() => ({

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

@@ -2,6 +2,8 @@ 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;