@blocklet/payment-react-headless 1.26.0

package/lib/checkout/hooks/useCrossSell.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCrossSell = useCrossSell;
+var _react = require("react");
+var _ahooks = require("ahooks");
+var _checkoutAugmented = require("../../types/checkout-augmented");
+var _SessionContext = require("../context/SessionContext");
+var _PaymentMethodContext = require("../context/PaymentMethodContext");
+var _lineItems = require("../core/lineItems");
+var _crossSell = require("../core/crossSell");
+function useCrossSell() {
+  const {
+    items,
+    session,
+    effectiveSessionId,
+    refresh
+  } = (0, _SessionContext.useSessionContext)();
+  const {
+    currency
+  } = (0, _PaymentMethodContext.usePaymentMethodContext)();
+  const currencyId = currency?.id || null;
+  const embeddedItem = (0, _react.useMemo)(() => (0, _lineItems.getCrossSellItem)(items), [items]);
+  const [fetchedItem, setFetchedItem] = (0, _react.useState)(null);
+  const itemPriceIds = (0, _react.useMemo)(() => items.map(i => i.price_id).join(","), [items]);
+  const hasCrossSellInItems = (0, _react.useMemo)(() => items.some(i => i.cross_sell), [items]);
+  (0, _react.useEffect)(() => {
+    if (!effectiveSessionId || !session) return void 0;
+    if (session.status === "complete") return void 0;
+    if (embeddedItem) {
+      setFetchedItem(null);
+      return void 0;
+    }
+    if (hasCrossSellInItems) {
+      return void 0;
+    }
+    let cancelled = false;
+    (0, _crossSell.fetchCrossSellItem)(effectiveSessionId).then(item2 => {
+      if (!cancelled) {
+        setFetchedItem(item2);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [effectiveSessionId, session?.id, embeddedItem, itemPriceIds, hasCrossSellInItems]);
+  const item = embeddedItem || fetchedItem;
+  const required = (0, _react.useMemo)(() => items.some(i => i.cross_sell_required), [items]);
+  const add = (0, _ahooks.useMemoizedFn)(async () => {
+    if (session?.status === "complete") return;
+    const crossSellItemPrice = (0, _lineItems.getCrossSellItem)(items);
+    if (!crossSellItemPrice) return;
+    try {
+      await (0, _crossSell.addCrossSellItem)(effectiveSessionId, crossSellItemPrice.id, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to add cross-sell:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const remove = (0, _ahooks.useMemoizedFn)(async () => {
+    if (session?.status === "complete") return;
+    try {
+      await (0, _crossSell.removeCrossSellItem)(effectiveSessionId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to remove cross-sell:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  return {
+    item,
+    required,
+    add,
+    remove
+  };
+}

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

@@ -0,0 +1,14 @@
+import type { FieldConfig, CheckoutFormData } from '../types';
+import type { SessionData } from './useCheckoutSession';
+export interface UseCustomerFormReturn {
+    fields: FieldConfig[];
+    values: CheckoutFormData;
+    onChange: (field: string, value: string | boolean | Record<string, string>) => void;
+    errors: Partial<Record<string, string>>;
+    touched: Record<string, boolean>;
+    validate: () => Promise<boolean>;
+    validateField: (field: string) => Promise<void>;
+    /** Re-fetch customer info from backend and update form values (e.g. after login) */
+    refetchCustomer: () => Promise<void>;
+}
+export declare function useCustomerForm(sessionData: SessionData | null, currencyId: string | null, methodId: string | null): UseCustomerFormReturn;

package/lib/checkout/hooks/useCustomerForm.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCustomerForm = useCustomerForm;
+var _react = require("react");
+var _ahooks = require("ahooks");
+var _api = _interopRequireWildcard(require("../../shared/api"));
+var _validation = require("../../shared/validation");
+var _customerForm = require("../core/customerForm");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function useCustomerForm(sessionData, currencyId, methodId) {
+  const session = sessionData?.checkoutSession;
+  const customer = sessionData?.customer;
+  const fields = (0, _react.useMemo)(() => (0, _customerForm.buildFields)(session), [session?.id]);
+  const [values, setValues] = (0, _react.useState)(() => (0, _customerForm.createInitialValues)(session, customer));
+  const [errors, setErrors] = (0, _react.useState)({});
+  const [touched, setTouched] = (0, _react.useState)({});
+  const [prefetched, setPrefetched] = (0, _react.useState)(false);
+  (0, _react.useEffect)(() => {
+    if (session && !prefetched) {
+      setValues((0, _customerForm.createInitialValues)(session, customer));
+    }
+  }, [session?.id]);
+  (0, _react.useEffect)(() => {
+    if (currencyId || methodId) {
+      setValues(prev => ({
+        ...prev,
+        ...(currencyId && {
+          payment_currency: currencyId
+        }),
+        ...(methodId && {
+          payment_method: methodId
+        })
+      }));
+    }
+  }, [currencyId, methodId]);
+  (0, _react.useEffect)(() => {
+    if (!session || prefetched || session.status === "complete") return;
+    const fetchCustomer = async () => {
+      try {
+        const {
+          data
+        } = await _api.default.get(`${_api.API.CUSTOMER_ME}?fallback=1&skipSummary=1`);
+        if (data) {
+          setPrefetched(true);
+          setValues(prev => ({
+            ...prev,
+            customer_name: prev.customer_name || data.name || "",
+            customer_email: prev.customer_email || data.email || "",
+            customer_phone: prev.customer_phone || data.phone || "",
+            billing_address: {
+              ...prev.billing_address,
+              country: prev.billing_address?.country || data.address?.country || "",
+              state: prev.billing_address?.state || data.address?.state || "",
+              city: prev.billing_address?.city || data.address?.city || "",
+              line1: prev.billing_address?.line1 || data.address?.line1 || "",
+              line2: prev.billing_address?.line2 || data.address?.line2 || "",
+              postal_code: prev.billing_address?.postal_code || data.address?.postal_code || ""
+            }
+          }));
+        }
+      } catch {}
+    };
+    fetchCustomer();
+  }, [session?.id]);
+  const onChange = (0, _ahooks.useMemoizedFn)((field, value) => {
+    setValues(prev => (0, _customerForm.setNestedValue)(prev, field, value));
+    setTouched(prev => ({
+      ...prev,
+      [field]: true
+    }));
+  });
+  const getValidateOptions = (0, _ahooks.useMemoizedFn)(() => ({
+    phoneEnabled: !!session?.phone_number_collection?.enabled,
+    addressMode: session?.billing_address_collection,
+    fieldValidation: session?.metadata?.page_info?.field_validation
+  }));
+  const validate = (0, _ahooks.useMemoizedFn)(async () => {
+    const result = await (0, _validation.validateForm)(values, getValidateOptions());
+    setErrors(result.errors);
+    return result.valid;
+  });
+  const validateField = (0, _ahooks.useMemoizedFn)(async field => {
+    const result = await (0, _validation.validateForm)(values, getValidateOptions());
+    setErrors(prev => {
+      const next = {
+        ...prev
+      };
+      if (result.errors[field]) {
+        next[field] = result.errors[field];
+      } else {
+        delete next[field];
+      }
+      return next;
+    });
+  });
+  const refetchCustomer = (0, _ahooks.useMemoizedFn)(async () => {
+    try {
+      const {
+        data
+      } = await _api.default.get(`${_api.API.CUSTOMER_ME}?fallback=1&skipSummary=1`);
+      if (data) {
+        setPrefetched(true);
+        setValues(prev => ({
+          ...prev,
+          customer_name: data.name || prev.customer_name || "",
+          customer_email: data.email || prev.customer_email || "",
+          customer_phone: data.phone || prev.customer_phone || "",
+          billing_address: {
+            ...prev.billing_address,
+            country: data.address?.country || prev.billing_address?.country || "",
+            state: data.address?.state || prev.billing_address?.state || "",
+            city: data.address?.city || prev.billing_address?.city || "",
+            line1: data.address?.line1 || prev.billing_address?.line1 || "",
+            line2: data.address?.line2 || prev.billing_address?.line2 || "",
+            postal_code: data.address?.postal_code || prev.billing_address?.postal_code || ""
+          }
+        }));
+      }
+    } catch {}
+  });
+  return {
+    fields,
+    values,
+    onChange,
+    errors,
+    touched,
+    validate,
+    validateField,
+    refetchCustomer
+  };
+}

package/lib/checkout/hooks/useCustomerFormFeature.d.ts

@@ -0,0 +1,2 @@
+import type { UseCustomerFormReturn } from './useCustomerForm';
+export declare function useCustomerFormFeature(): UseCustomerFormReturn;

package/lib/checkout/hooks/useCustomerFormFeature.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCustomerFormFeature = useCustomerFormFeature;
+var _CustomerFormContext = require("../context/CustomerFormContext");
+function useCustomerFormFeature() {
+  return (0, _CustomerFormContext.useCustomerFormContext)();
+}

package/lib/checkout/hooks/useExchangeRate.d.ts

@@ -0,0 +1,11 @@
+export interface UseExchangeRateReturn {
+    value: string | null;
+    display: string | null;
+    provider: string | null;
+    providerDisplay: string | null;
+    fetchedAt: number | null;
+    status: 'loading' | 'available' | 'unavailable';
+    hasDynamicPricing: boolean;
+    refresh: () => Promise<void>;
+}
+export declare function useExchangeRate(): UseExchangeRateReturn;

package/lib/checkout/hooks/useExchangeRate.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useExchangeRate = useExchangeRate;
+var _ExchangeRateContext = require("../context/ExchangeRateContext");
+var _format = require("../../shared/format");
+function useExchangeRate() {
+  const {
+    rate,
+    provider,
+    providerDisplay,
+    fetchedAt,
+    status,
+    hasDynamicPricing,
+    refresh
+  } = (0, _ExchangeRateContext.useExchangeRateContext)();
+  return {
+    value: (0, _format.formatExchangeRate)(rate),
+    display: rate ? (0, _format.formatExchangeRateDisplay)(rate) : null,
+    provider,
+    providerDisplay,
+    fetchedAt,
+    status,
+    hasDynamicPricing,
+    refresh
+  };
+}

package/lib/checkout/hooks/useLineItems.d.ts

@@ -0,0 +1,22 @@
+import type { TLineItemExpanded, TPrice } from '@blocklet/payment-types';
+export interface UseLineItemsReturn {
+    items: Array<TLineItemExpanded & {
+        adjustable_quantity?: {
+            enabled: boolean;
+            minimum?: number;
+            maximum?: number;
+        };
+    }>;
+    /** true if all items pass inventory check (quantity_available, quantity_limit_per_checkout) */
+    inventoryOk: boolean;
+    updateQuantity: (itemId: string, qty: number) => Promise<void>;
+    upsell: (fromId: string, toId: string) => Promise<void>;
+    downsell: (priceId: string) => Promise<void>;
+    crossSellItem: TPrice | null;
+    crossSellRequired: boolean;
+    addCrossSell: () => Promise<void>;
+    removeCrossSell: () => Promise<void>;
+    isDonation: boolean;
+    setDonationAmount: (priceId: string, amount: string) => Promise<void>;
+}
+export declare function useLineItems(): UseLineItemsReturn;

package/lib/checkout/hooks/useLineItems.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLineItems = useLineItems;
+var _react = require("react");
+var _ahooks = require("ahooks");
+var _checkoutAugmented = require("../../types/checkout-augmented");
+var _SessionContext = require("../context/SessionContext");
+var _PaymentMethodContext = require("../context/PaymentMethodContext");
+var _lineItems = require("../core/lineItems");
+var _crossSell = require("../core/crossSell");
+function useLineItems() {
+  const {
+    items,
+    session,
+    effectiveSessionId,
+    isDonation,
+    refresh
+  } = (0, _SessionContext.useSessionContext)();
+  const {
+    currency
+  } = (0, _PaymentMethodContext.usePaymentMethodContext)();
+  const currencyId = currency?.id || null;
+  const defaultQtyApplied = (0, _react.useRef)(false);
+  (0, _react.useEffect)(() => {
+    if (defaultQtyApplied.current || !effectiveSessionId || !items.length || !currencyId || session?.status === "complete") return;
+    try {
+      const params = new URLSearchParams(window.location.search);
+      for (const item of items) {
+        const qtyStr = params.get(`qty_${item.price_id}`) || params.get(`qty_${item.price?.id}`) || params.get("qty");
+        if (qtyStr) {
+          const qty = Math.max(1, parseInt(qtyStr, 10));
+          if (Number.isFinite(qty) && qty !== item.quantity) {
+            defaultQtyApplied.current = true;
+            (0, _lineItems.adjustQuantity)(effectiveSessionId, item.price_id, qty, currencyId, session, refresh);
+            break;
+          }
+        }
+      }
+    } catch {}
+  }, [effectiveSessionId, items, currencyId]);
+  const updateQuantity = (0, _ahooks.useMemoizedFn)(async (itemId, qty) => {
+    if (session?.status === "complete") return;
+    try {
+      await (0, _lineItems.adjustQuantity)(effectiveSessionId, itemId, qty, currencyId, session, refresh);
+    } catch (err) {
+      console.error("Failed to update quantity:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const upsell = (0, _ahooks.useMemoizedFn)(async (fromId, toId) => {
+    if (session?.status === "complete") return;
+    await (0, _lineItems.performUpsell)(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+  });
+  const downsell = (0, _ahooks.useMemoizedFn)(async priceId => {
+    if (session?.status === "complete") return;
+    await (0, _lineItems.performDownsell)(effectiveSessionId, priceId, session, currencyId, refresh);
+  });
+  const embeddedCrossSellItem = (0, _react.useMemo)(() => (0, _lineItems.getCrossSellItem)(items), [items]);
+  const [fetchedCrossSellItem, setFetchedCrossSellItem] = (0, _react.useState)(null);
+  const itemPriceIds = (0, _react.useMemo)(() => items.map(i => i.price_id).join(","), [items]);
+  const hasCrossSellInItems = (0, _react.useMemo)(() => items.some(i => i.cross_sell), [items]);
+  (0, _react.useEffect)(() => {
+    if (!effectiveSessionId || !session) return void 0;
+    if (session.status === "complete") return void 0;
+    if (embeddedCrossSellItem) {
+      setFetchedCrossSellItem(null);
+      return void 0;
+    }
+    if (hasCrossSellInItems) {
+      return void 0;
+    }
+    let cancelled = false;
+    (0, _crossSell.fetchCrossSellItem)(effectiveSessionId).then(item => {
+      if (!cancelled) {
+        setFetchedCrossSellItem(item);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [effectiveSessionId, session?.id, embeddedCrossSellItem, itemPriceIds, hasCrossSellInItems]);
+  const crossSellItem = embeddedCrossSellItem || fetchedCrossSellItem;
+  const crossSellRequired = (0, _react.useMemo)(() => items.some(item => item.cross_sell_required), [items]);
+  const addCrossSell = (0, _ahooks.useMemoizedFn)(async () => {
+    if (session?.status === "complete") return;
+    if (!crossSellItem) return;
+    try {
+      await (0, _crossSell.addCrossSellItem)(effectiveSessionId, crossSellItem.id, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to add cross-sell:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const removeCrossSell = (0, _ahooks.useMemoizedFn)(async () => {
+    if (session?.status === "complete") return;
+    try {
+      await (0, _crossSell.removeCrossSellItem)(effectiveSessionId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to remove cross-sell:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const setDonationAmount = (0, _ahooks.useMemoizedFn)(async (priceId, amount) => {
+    if (session?.status === "complete") return;
+    if (!isDonation) return;
+    try {
+      await (0, _lineItems.changeDonationAmount)(effectiveSessionId, priceId, amount, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to change amount:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const mappedItems = (0, _react.useMemo)(() => items.map(item => ({
+    ...item,
+    adjustable_quantity: item.adjustable_quantity
+  })), [items]);
+  const inventoryOk = (0, _react.useMemo)(() => items.every(item => {
+    const {
+      price
+    } = item;
+    if (!price) return true;
+    const q = Number(item.quantity) || 0;
+    const available = price.quantity_available || 0;
+    const sold = price.quantity_sold || 0;
+    const limitPerCheckout = price.quantity_limit_per_checkout || 0;
+    if (available > 0 && sold + q > available) return false;
+    if (limitPerCheckout > 0 && limitPerCheckout < q) return false;
+    return true;
+  }), [items]);
+  return {
+    items: mappedItems,
+    inventoryOk,
+    updateQuantity,
+    upsell,
+    downsell,
+    crossSellItem,
+    crossSellRequired,
+    addCrossSell,
+    removeCrossSell,
+    isDonation,
+    setDonationAmount
+  };
+}

package/lib/checkout/hooks/usePaymentMethod.d.ts

@@ -0,0 +1,26 @@
+import type { TPaymentMethodExpanded, TPaymentCurrency } from '@blocklet/payment-types';
+import type { SessionData } from './useCheckoutSession';
+export interface UsePaymentMethodReturn {
+    current: TPaymentMethodExpanded;
+    currency: TPaymentCurrency;
+    available: TPaymentMethodExpanded[];
+    currencies: TPaymentCurrency[];
+    isStripe: boolean;
+    isCrypto: boolean;
+    isCredit: boolean;
+    switching: boolean;
+    setType: (type: 'stripe' | 'crypto') => Promise<void>;
+    types: Array<{
+        type: 'stripe' | 'crypto';
+        label: string;
+        currencies: TPaymentCurrency[];
+        active: boolean;
+    }>;
+    setCurrency: (currencyId: string) => Promise<void>;
+    stripe: {
+        publishableKey: string | null;
+        clientSecret: string | null;
+        status: 'idle' | 'ready' | 'processing' | 'succeeded' | 'failed';
+    } | null;
+}
+export declare function usePaymentMethod(sessionData: SessionData | null, sessionId: string, refreshSession: (force?: boolean) => Promise<void>): UsePaymentMethodReturn;

package/lib/checkout/hooks/usePaymentMethod.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePaymentMethod = usePaymentMethod;
+var _react = require("react");
+var _ahooks = require("ahooks");
+var _checkoutAugmented = require("../../types/checkout-augmented");
+var _api = _interopRequireWildcard(require("../../shared/api"));
+var _paymentMethod = require("../core/paymentMethod");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function usePaymentMethod(sessionData, sessionId, refreshSession) {
+  const methods = sessionData?.paymentMethods || [];
+  const session = sessionData?.checkoutSession;
+  const [currencyId, setCurrencyId] = (0, _react.useState)(() => (0, _paymentMethod.getInitialCurrencyId)(session, methods));
+  const [switching, setSwitching] = (0, _react.useState)(false);
+  const initialSyncedRef = (0, _react.useRef)(null);
+  (0, _react.useEffect)(() => {
+    if (session && !currencyId) {
+      setCurrencyId((0, _paymentMethod.getInitialCurrencyId)(session, methods));
+    }
+  }, [session?.id]);
+  const {
+    method: currentMethod,
+    currency: currentCurrency
+  } = (0, _react.useMemo)(() => (0, _paymentMethod.findMethodAndCurrency)(methods, currencyId), [methods, currencyId]);
+  const allCurrencies = (0, _react.useMemo)(() => (0, _paymentMethod.flattenCurrencies)(methods), [methods]);
+  const isStripe = currentMethod?.type === "stripe";
+  const isCrypto = currentMethod?.type !== "stripe" && currentMethod?.type !== void 0;
+  const isCredit = currentCurrency?.type === "credit";
+  const types = (0, _react.useMemo)(() => (0, _paymentMethod.buildPaymentTypes)(methods, currentMethod), [methods, currentMethod]);
+  const setType = (0, _ahooks.useMemoizedFn)(async type => {
+    const targetMethod = methods.find(m => type === "stripe" ? m.type === "stripe" : m.type !== "stripe");
+    if (!targetMethod) return;
+    const firstCurrency = targetMethod.payment_currencies?.[0];
+    if (firstCurrency) {
+      await switchCurrency(firstCurrency.id);
+    }
+  });
+  const switchCurrency = (0, _ahooks.useMemoizedFn)(async newCurrencyId => {
+    if (session?.status === "complete") return;
+    const {
+      method
+    } = (0, _paymentMethod.findMethodAndCurrency)(methods, newCurrencyId);
+    if (!method || !sessionId) return;
+    setSwitching(true);
+    try {
+      await _api.default.put(_api.API.SWITCH_CURRENCY(sessionId), {
+        currency_id: newCurrencyId,
+        payment_method_id: method.id
+      });
+      setCurrencyId(newCurrencyId);
+      try {
+        localStorage.setItem((0, _paymentMethod.getCurrencyStorageKey)(session?.user?.did), newCurrencyId);
+      } catch {}
+      await refreshSession(true);
+    } catch (err) {
+      console.error("Failed to switch currency:", (0, _checkoutAugmented.getErrorMessage)(err));
+      if (session?.currency_id) {
+        setCurrencyId(session.currency_id);
+      }
+    } finally {
+      setSwitching(false);
+    }
+  });
+  (0, _react.useEffect)(() => {
+    if (!session?.id || !currencyId || !methods.length) return;
+    if (initialSyncedRef.current === session.id) return;
+    initialSyncedRef.current = session.id;
+    const sessionCurrencyId = session.currency_id;
+    if (session.status === "complete") return;
+    if (sessionCurrencyId && sessionCurrencyId !== currencyId) {
+      switchCurrency(currencyId);
+    }
+  }, [session?.id, currencyId, methods.length]);
+  const stripe = (0, _react.useMemo)(() => {
+    if (!currentMethod || currentMethod.type !== "stripe") return null;
+    const stripeSettings = currentMethod.settings?.stripe;
+    return {
+      publishableKey: stripeSettings?.publishable_key || null,
+      clientSecret: sessionData?.paymentIntent?.client_secret || null,
+      status: "idle"
+    };
+  }, [currentMethod, sessionData?.paymentIntent]);
+  return {
+    current: currentMethod,
+    currency: currentCurrency,
+    available: methods,
+    currencies: allCurrencies,
+    isStripe,
+    isCrypto,
+    isCredit,
+    switching,
+    setType,
+    types,
+    setCurrency: switchCurrency,
+    stripe
+  };
+}

package/lib/checkout/hooks/usePaymentMethodFeature.d.ts

@@ -0,0 +1,2 @@
+import type { UsePaymentMethodReturn } from './usePaymentMethod';
+export declare function usePaymentMethodFeature(): UsePaymentMethodReturn;

package/lib/checkout/hooks/usePaymentMethodFeature.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePaymentMethodFeature = usePaymentMethodFeature;
+var _PaymentMethodContext = require("../context/PaymentMethodContext");
+function usePaymentMethodFeature() {
+  return (0, _PaymentMethodContext.usePaymentMethodContext)();
+}

package/lib/checkout/hooks/usePricing.d.ts

@@ -0,0 +1,57 @@
+import type { TPaymentCurrency } from '@blocklet/payment-types';
+import type { SessionData } from './useCheckoutSession';
+export interface UsePricingReturn {
+    subtotal: string;
+    paymentAmount: string;
+    discount: string | null;
+    tax: {
+        amount: string;
+        rate: number;
+        inclusive: boolean;
+    } | null;
+    staking: string | null;
+    total: string;
+    usdEquivalent: string | null;
+    hasDynamicPricing: boolean;
+    rate: {
+        value: string | null;
+        display: string | null;
+        provider: string | null;
+        providerDisplay: string | null;
+        fetchedAt: number | null;
+        status: 'loading' | 'available' | 'unavailable';
+        refresh: () => Promise<void>;
+    };
+    quote: {
+        locked: boolean;
+        lockedAt: number | null;
+        expiresAt: number | null;
+        expired: boolean;
+        baseCurrency: string | null;
+    };
+    slippage: {
+        percent: number;
+        set: (config: {
+            mode: string;
+            percent: number;
+        }) => Promise<void>;
+    };
+    promotion: {
+        applied: boolean;
+        code: string | null;
+        active: boolean;
+        inactiveReason: string | null;
+        apply: (code: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        remove: () => Promise<void>;
+    };
+    trial: {
+        active: boolean;
+        days: number;
+        afterTrialPrice: string | null;
+        afterTrialInterval: string | null;
+    };
+}
+export declare function usePricing(sessionData: SessionData | null, sessionId: string, currency: TPaymentCurrency | null, isStripe: boolean, refreshSession: (force?: boolean) => Promise<void>, paymentMethodType?: string | null): UsePricingReturn;