@blocklet/payment-react-headless 1.26.0

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

@@ -0,0 +1,34 @@
+export { useCheckout } from './useCheckout';
+export { useCheckoutSession } from './useCheckoutSession';
+export type { UseCheckoutSessionReturn, SessionData } from './useCheckoutSession';
+export { usePaymentMethod } from './usePaymentMethod';
+export type { UsePaymentMethodReturn } from './usePaymentMethod';
+export { usePricing } from './usePricing';
+export type { UsePricingReturn } from './usePricing';
+export { useCustomerForm } from './useCustomerForm';
+export type { UseCustomerFormReturn } from './useCustomerForm';
+export { useSubmit } from './useSubmit';
+export type { UseSubmitReturn, VendorStatus, VendorOrderStatus } from './useSubmit';
+export { useProduct } from './useProduct';
+export type { UseProductReturn } from './useProduct';
+export { useLineItems } from './useLineItems';
+export type { UseLineItemsReturn } from './useLineItems';
+export { useBillingInterval } from './useBillingInterval';
+export type { UseBillingIntervalReturn, BillingIntervalData } from './useBillingInterval';
+export { useUpsell } from './useUpsell';
+export type { UseUpsellReturn } from './useUpsell';
+export { useCrossSell } from './useCrossSell';
+export type { UseCrossSellReturn } from './useCrossSell';
+export { usePromotion } from './usePromotion';
+export type { UsePromotionReturn } from './usePromotion';
+export { useExchangeRate } from './useExchangeRate';
+export type { UseExchangeRateReturn } from './useExchangeRate';
+export { useSlippage } from './useSlippage';
+export type { UseSlippageReturn } from './useSlippage';
+export { useCheckoutStatus } from './useCheckoutStatus';
+export type { UseCheckoutStatusReturn } from './useCheckoutStatus';
+export { usePricingFeature } from './usePricingFeature';
+export type { UsePricingFeatureReturn } from './usePricingFeature';
+export { usePaymentMethodFeature } from './usePaymentMethodFeature';
+export { useCustomerFormFeature } from './useCustomerFormFeature';
+export { useSubmitFeature } from './useSubmitFeature';

package/lib/checkout/hooks/index.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useBillingInterval", {
+  enumerable: true,
+  get: function () {
+    return _useBillingInterval.useBillingInterval;
+  }
+});
+Object.defineProperty(exports, "useCheckout", {
+  enumerable: true,
+  get: function () {
+    return _useCheckout.useCheckout;
+  }
+});
+Object.defineProperty(exports, "useCheckoutSession", {
+  enumerable: true,
+  get: function () {
+    return _useCheckoutSession.useCheckoutSession;
+  }
+});
+Object.defineProperty(exports, "useCheckoutStatus", {
+  enumerable: true,
+  get: function () {
+    return _useCheckoutStatus.useCheckoutStatus;
+  }
+});
+Object.defineProperty(exports, "useCrossSell", {
+  enumerable: true,
+  get: function () {
+    return _useCrossSell.useCrossSell;
+  }
+});
+Object.defineProperty(exports, "useCustomerForm", {
+  enumerable: true,
+  get: function () {
+    return _useCustomerForm.useCustomerForm;
+  }
+});
+Object.defineProperty(exports, "useCustomerFormFeature", {
+  enumerable: true,
+  get: function () {
+    return _useCustomerFormFeature.useCustomerFormFeature;
+  }
+});
+Object.defineProperty(exports, "useExchangeRate", {
+  enumerable: true,
+  get: function () {
+    return _useExchangeRate.useExchangeRate;
+  }
+});
+Object.defineProperty(exports, "useLineItems", {
+  enumerable: true,
+  get: function () {
+    return _useLineItems.useLineItems;
+  }
+});
+Object.defineProperty(exports, "usePaymentMethod", {
+  enumerable: true,
+  get: function () {
+    return _usePaymentMethod.usePaymentMethod;
+  }
+});
+Object.defineProperty(exports, "usePaymentMethodFeature", {
+  enumerable: true,
+  get: function () {
+    return _usePaymentMethodFeature.usePaymentMethodFeature;
+  }
+});
+Object.defineProperty(exports, "usePricing", {
+  enumerable: true,
+  get: function () {
+    return _usePricing.usePricing;
+  }
+});
+Object.defineProperty(exports, "usePricingFeature", {
+  enumerable: true,
+  get: function () {
+    return _usePricingFeature.usePricingFeature;
+  }
+});
+Object.defineProperty(exports, "useProduct", {
+  enumerable: true,
+  get: function () {
+    return _useProduct.useProduct;
+  }
+});
+Object.defineProperty(exports, "usePromotion", {
+  enumerable: true,
+  get: function () {
+    return _usePromotion.usePromotion;
+  }
+});
+Object.defineProperty(exports, "useSlippage", {
+  enumerable: true,
+  get: function () {
+    return _useSlippage.useSlippage;
+  }
+});
+Object.defineProperty(exports, "useSubmit", {
+  enumerable: true,
+  get: function () {
+    return _useSubmit.useSubmit;
+  }
+});
+Object.defineProperty(exports, "useSubmitFeature", {
+  enumerable: true,
+  get: function () {
+    return _useSubmitFeature.useSubmitFeature;
+  }
+});
+Object.defineProperty(exports, "useUpsell", {
+  enumerable: true,
+  get: function () {
+    return _useUpsell.useUpsell;
+  }
+});
+var _useCheckout = require("./useCheckout");
+var _useCheckoutSession = require("./useCheckoutSession");
+var _usePaymentMethod = require("./usePaymentMethod");
+var _usePricing = require("./usePricing");
+var _useCustomerForm = require("./useCustomerForm");
+var _useSubmit = require("./useSubmit");
+var _useProduct = require("./useProduct");
+var _useLineItems = require("./useLineItems");
+var _useBillingInterval = require("./useBillingInterval");
+var _useUpsell = require("./useUpsell");
+var _useCrossSell = require("./useCrossSell");
+var _usePromotion = require("./usePromotion");
+var _useExchangeRate = require("./useExchangeRate");
+var _useSlippage = require("./useSlippage");
+var _useCheckoutStatus = require("./useCheckoutStatus");
+var _usePricingFeature = require("./usePricingFeature");
+var _usePaymentMethodFeature = require("./usePaymentMethodFeature");
+var _useCustomerFormFeature = require("./useCustomerFormFeature");
+var _useSubmitFeature = require("./useSubmitFeature");

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

@@ -0,0 +1,14 @@
+import { type BillingIntervalType } from '../core/billingInterval';
+export interface BillingIntervalData {
+    current: BillingIntervalType | null;
+    available: Array<{
+        interval: BillingIntervalType;
+        priceId: string;
+        amount: string;
+        savings: string | null;
+    }>;
+    switch: (interval: BillingIntervalType) => Promise<void>;
+    switching: boolean;
+}
+export type UseBillingIntervalReturn = BillingIntervalData | null;
+export declare function useBillingInterval(): UseBillingIntervalReturn;

package/lib/checkout/hooks/useBillingInterval.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBillingInterval = useBillingInterval;
+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 _billingInterval = require("../core/billingInterval");
+var _lineItems = require("../core/lineItems");
+function useBillingInterval() {
+  const {
+    items,
+    session,
+    effectiveSessionId,
+    refresh
+  } = (0, _SessionContext.useSessionContext)();
+  const {
+    currency
+  } = (0, _PaymentMethodContext.usePaymentMethodContext)();
+  const currencyId = currency?.id || null;
+  const [switching, setSwitching] = (0, _react.useState)(false);
+  const upsell = (0, _ahooks.useMemoizedFn)(async (fromId, toId) => {
+    try {
+      await (0, _lineItems.performUpsell)(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to upsell:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const downsell = (0, _ahooks.useMemoizedFn)(async priceId => {
+    try {
+      await (0, _lineItems.performDownsell)(effectiveSessionId, priceId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to downsell:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  return (0, _react.useMemo)(() => {
+    const parsed = (0, _billingInterval.parseBillingInterval)(items);
+    if (!parsed) return null;
+    return {
+      current: parsed.current,
+      available: parsed.available,
+      switching,
+      switch: async interval => {
+        const target = parsed.available.find(a => a.interval === interval);
+        if (!target || switching) return;
+        setSwitching(true);
+        try {
+          if (!parsed.firstItem.upsell_price_id && target.priceId) {
+            await upsell(parsed.firstItem.price_id, target.priceId);
+          } else if (parsed.firstItem.upsell_price_id) {
+            await downsell(parsed.firstItem.upsell_price_id);
+          }
+        } finally {
+          setSwitching(false);
+        }
+      }
+    };
+  }, [items, effectiveSessionId, switching]);
+}

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

@@ -0,0 +1,2 @@
+import type { UseCheckoutReturn } from '../types';
+export declare function useCheckout(sessionId: string): UseCheckoutReturn;

package/lib/checkout/hooks/useCheckout.js

@@ -0,0 +1,190 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCheckout = useCheckout;
+var _react = require("react");
+var _ahooks = require("ahooks");
+var _checkoutAugmented = require("../../types/checkout-augmented");
+var _useCheckoutSession = require("./useCheckoutSession");
+var _usePaymentMethod = require("./usePaymentMethod");
+var _usePricing = require("./usePricing");
+var _useCustomerForm = require("./useCustomerForm");
+var _useSubmit = require("./useSubmit");
+var _lineItems = require("../core/lineItems");
+var _crossSell = require("../core/crossSell");
+var _billingInterval = require("../core/billingInterval");
+function useCheckout(sessionId) {
+  const {
+    isLoading,
+    error,
+    errorCode,
+    refresh,
+    sessionData,
+    resolvedSessionId,
+    vendorCount,
+    product,
+    subscription,
+    pageInfo
+  } = (0, _useCheckoutSession.useCheckoutSession)(sessionId);
+  const session = sessionData?.checkoutSession;
+  const effectiveSessionId = resolvedSessionId || sessionId;
+  const paymentMethodHook = (0, _usePaymentMethod.usePaymentMethod)(sessionData, effectiveSessionId, refresh);
+  const pricingHook = (0, _usePricing.usePricing)(sessionData, effectiveSessionId, paymentMethodHook.currency, paymentMethodHook.isStripe, refresh, paymentMethodHook.current?.type || null);
+  const formHook = (0, _useCustomerForm.useCustomerForm)(sessionData, paymentMethodHook.currency?.id || null, paymentMethodHook.current?.id || null);
+  const isDonation = session?.submit_type === "donate";
+  const submitHook = (0, _useSubmit.useSubmit)(sessionData, effectiveSessionId, paymentMethodHook.currency?.id || null, paymentMethodHook.isStripe, paymentMethodHook.isCredit, isDonation, formHook.values, formHook.validate, refresh);
+  const items = session?.line_items || [];
+  const currencyId = paymentMethodHook.currency?.id || null;
+  const prevCurrencyRef = (0, _react.useRef)(null);
+  (0, _react.useEffect)(() => {
+    const currId = paymentMethodHook.currency?.id || null;
+    if (!currId || !session) return;
+    if (prevCurrencyRef.current === null || currId !== prevCurrencyRef.current) {
+      prevCurrencyRef.current = currId;
+      (0, _lineItems.recalculatePromotionIfNeeded)(session, effectiveSessionId, currId).then(() => refresh(true));
+    }
+  }, [paymentMethodHook.currency?.id, session?.id]);
+  const updateQuantity = (0, _ahooks.useMemoizedFn)(async (itemId, qty) => {
+    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) => {
+    try {
+      await (0, _lineItems.performUpsell)(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to upsell:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const downsell = (0, _ahooks.useMemoizedFn)(async priceId => {
+    try {
+      await (0, _lineItems.performDownsell)(effectiveSessionId, priceId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to downsell:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const embeddedCrossSellItem = (0, _react.useMemo)(() => (0, _lineItems.getCrossSellItem)(items), [items]);
+  const [fetchedCrossSellItem, setFetchedCrossSellItem] = (0, _react.useState)(null);
+  (0, _react.useEffect)(() => {
+    if (!effectiveSessionId || !session) return void 0;
+    if (embeddedCrossSellItem) return void 0;
+    let cancelled = false;
+    (0, _crossSell.fetchCrossSellItem)(effectiveSessionId).then(item => {
+      if (!cancelled && item) {
+        setFetchedCrossSellItem(item);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [effectiveSessionId, session?.id, embeddedCrossSellItem]);
+  const crossSellItem = embeddedCrossSellItem || fetchedCrossSellItem;
+  const crossSellRequired = (0, _react.useMemo)(() => items.some(item => item.cross_sell_required), [items]);
+  const addCrossSell = (0, _ahooks.useMemoizedFn)(async () => {
+    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 () => {
+    try {
+      await (0, _crossSell.removeCrossSellItem)(effectiveSessionId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to remove cross-sell:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const billingInterval = (0, _react.useMemo)(() => {
+    const parsed = (0, _billingInterval.parseBillingInterval)(items);
+    if (!parsed) return null;
+    return {
+      current: parsed.current,
+      available: parsed.available,
+      switch: async interval => {
+        const target = parsed.available.find(a => a.interval === interval);
+        if (!target) return;
+        if (!parsed.firstItem.upsell_price_id && target.priceId) {
+          await upsell(parsed.firstItem.price_id, target.priceId);
+        } else if (parsed.firstItem.upsell_price_id) {
+          await downsell(parsed.firstItem.upsell_price_id);
+        }
+      }
+    };
+  }, [items, effectiveSessionId]);
+  const setDonationAmount = (0, _ahooks.useMemoizedFn)(async (priceId, amount) => {
+    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 canSubmit = submitHook.status === "idle" && !isLoading && !error && session?.status === "open";
+  const isCompleted = submitHook.status === "completed";
+  return {
+    isLoading,
+    error,
+    errorCode,
+    refresh: async () => {
+      await refresh();
+    },
+    product,
+    vendorCount,
+    lineItems: {
+      items: items.map(item => ({
+        ...item,
+        adjustable_quantity: item.adjustable_quantity
+      })),
+      updateQuantity,
+      upsell,
+      downsell,
+      billingInterval,
+      crossSellItem,
+      crossSellRequired,
+      addCrossSell,
+      removeCrossSell
+    },
+    paymentMethod: {
+      current: paymentMethodHook.current,
+      currency: paymentMethodHook.currency,
+      available: paymentMethodHook.available,
+      currencies: paymentMethodHook.currencies,
+      isStripe: paymentMethodHook.isStripe,
+      isCrypto: paymentMethodHook.isCrypto,
+      isCredit: paymentMethodHook.isCredit,
+      setType: paymentMethodHook.setType,
+      types: paymentMethodHook.types,
+      setCurrency: paymentMethodHook.setCurrency
+    },
+    stripe: paymentMethodHook.stripe,
+    pricing: pricingHook,
+    form: formHook,
+    submit: submitHook,
+    subscription,
+    pageInfo,
+    canSubmit,
+    isCompleted,
+    isDonation,
+    setDonationAmount,
+    customer: sessionData?.customer ? {
+      name: sessionData.customer.name || "",
+      email: sessionData.customer.email || "",
+      phone: sessionData.customer.phone || "",
+      address: {
+        country: sessionData.customer.address?.country || "",
+        state: sessionData.customer.address?.state || "",
+        city: sessionData.customer.address?.city || "",
+        line1: sessionData.customer.address?.line1 || "",
+        line2: sessionData.customer.address?.line2 || "",
+        postal_code: sessionData.customer.address?.postal_code || ""
+      }
+    } : null,
+    livemode: !!session?.livemode,
+    session: session || null
+  };
+}

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

@@ -0,0 +1,58 @@
+import type { TCheckoutSessionExpanded, TPaymentMethodExpanded, TPaymentIntent, TCustomer } from '@blocklet/payment-types';
+export interface SessionData {
+    checkoutSession: TCheckoutSessionExpanded;
+    paymentMethods: TPaymentMethodExpanded[];
+    paymentIntent?: TPaymentIntent;
+    customer?: TCustomer;
+    quotes?: Record<string, {
+        quote_id: string;
+        expires_at: number;
+        quoted_amount: string;
+        exchange_rate?: string;
+        rate_provider_name?: string;
+        rate_provider_id?: string;
+    }>;
+    rateUnavailable?: boolean;
+    rateError?: string;
+}
+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;
+    refresh: (forceRefresh?: boolean) => Promise<void>;
+    /** Directly update session data (e.g. after completion polling returns fresh data) */
+    setSessionData: (data: SessionData) => void;
+    sessionData: SessionData | null;
+    resolvedSessionId: string;
+    vendorCount: number;
+    product: {
+        name: string;
+        description: string;
+        images: string[];
+        features: Array<{
+            name: string;
+            icon?: string;
+        }>;
+        billing: {
+            mode: 'payment' | 'subscription';
+            interval: 'month' | 'year' | 'week' | 'day' | null;
+            intervalCount: number;
+            displayInterval: string;
+        };
+        metadata: Record<string, string>;
+    } | null;
+    subscription: {
+        mode: 'payment' | 'subscription' | 'setup';
+        showStake: boolean;
+        confirmMessage: string;
+    } | null;
+    pageInfo: {
+        formPurposeDescription?: {
+            en: string;
+            zh: string;
+        };
+        showProductFeatures: boolean;
+    } | null;
+}
+export declare function useCheckoutSession(sessionId: string): UseCheckoutSessionReturn;

package/lib/checkout/hooks/useCheckoutSession.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCheckoutSession = useCheckoutSession;
+var _react = require("react");
+var _ahooks = require("ahooks");
+var _api = _interopRequireWildcard(require("../../shared/api"));
+var _checkoutAugmented = require("../../types/checkout-augmented");
+var _session = require("../core/session");
+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 useCheckoutSession(sessionId) {
+  const [isLoading, setIsLoading] = (0, _react.useState)(true);
+  const [error, setError] = (0, _react.useState)(null);
+  const [sessionData, setSessionData] = (0, _react.useState)(null);
+  const abortRef = (0, _react.useRef)(null);
+  const mountedRef = (0, _react.useRef)(true);
+  const resolvedIdRef = (0, _react.useRef)(null);
+  const isPaymentLink = sessionId?.startsWith("plink_");
+  const resolveSessionId = (0, _ahooks.useMemoizedFn)(async () => {
+    if (!isPaymentLink) return sessionId;
+    if (resolvedIdRef.current) return resolvedIdRef.current;
+    const {
+      data
+    } = await _api.default.post(_api.API.START_PAYMENT_LINK(sessionId));
+    const resolved = data?.checkoutSession?.id;
+    if (!resolved) throw new Error("Failed to start payment link session");
+    resolvedIdRef.current = resolved;
+    return resolved;
+  });
+  const fetchSession = (0, _ahooks.useMemoizedFn)(async (forceRefresh = false) => {
+    if (abortRef.current) {
+      abortRef.current.abort();
+    }
+    abortRef.current = new AbortController();
+    if (!sessionId) {
+      setIsLoading(false);
+      setError("Session ID is required");
+      return;
+    }
+    try {
+      if (!forceRefresh) {
+        setIsLoading(true);
+      }
+      setError(null);
+      const realId = await resolveSessionId();
+      const url = forceRefresh ? `${_api.API.RETRIEVE_SESSION(realId)}?forceRefresh=1` : _api.API.RETRIEVE_SESSION(realId);
+      const {
+        data
+      } = await _api.default.get(url, {
+        signal: abortRef.current.signal
+      });
+      if (!mountedRef.current) return;
+      const cs = data?.checkoutSession;
+      if (cs) {
+        if (cs.status !== "complete" && cs.expires_at && cs.expires_at <= Math.round(Date.now() / 1e3)) {
+          setError("SESSION_EXPIRED");
+          setIsLoading(false);
+          return;
+        }
+        if (!cs.line_items?.length) {
+          setError("EMPTY_LINE_ITEMS");
+          setIsLoading(false);
+          return;
+        }
+      }
+      setSessionData(data);
+      setIsLoading(false);
+    } catch (err) {
+      if (!mountedRef.current) return;
+      const {
+        isCancelled,
+        message
+      } = (0, _checkoutAugmented.getAxiosErrorDetails)(err);
+      if (isCancelled) return;
+      setError(message || "Failed to load checkout session");
+      setIsLoading(false);
+    }
+  });
+  const refresh = (0, _react.useCallback)(async (forceRefresh = false) => {
+    await fetchSession(forceRefresh);
+  }, [fetchSession]);
+  (0, _react.useEffect)(() => {
+    mountedRef.current = true;
+    fetchSession();
+    return () => {
+      mountedRef.current = false;
+      if (abortRef.current) {
+        abortRef.current.abort();
+      }
+    };
+  }, [sessionId]);
+  const session = sessionData?.checkoutSession;
+  const resolvedSessionId = resolvedIdRef.current || (isPaymentLink ? "" : sessionId);
+  let errorCode = null;
+  if (error === "SESSION_EXPIRED") {
+    errorCode = "SESSION_EXPIRED";
+  } else if (error === "EMPTY_LINE_ITEMS") {
+    errorCode = "EMPTY_LINE_ITEMS";
+  }
+  const vendorCount = session?.line_items?.reduce((count, item) => {
+    return count + (item?.price?.product?.vendor_config?.length || 0);
+  }, 0) || 0;
+  return {
+    isLoading,
+    error,
+    errorCode,
+    refresh,
+    setSessionData,
+    sessionData,
+    resolvedSessionId,
+    vendorCount,
+    product: session ? (0, _session.parseProduct)(session) : null,
+    subscription: session ? (0, _session.parseSubscription)(session) : null,
+    pageInfo: session ? (0, _session.parsePageInfo)(session) : null
+  };
+}

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

@@ -0,0 +1,10 @@
+export interface UseCheckoutStatusReturn {
+    isLoading: boolean;
+    error: string | null;
+    errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null;
+    canSubmit: boolean;
+    isCompleted: boolean;
+    isDonation: boolean;
+    livemode: boolean;
+}
+export declare function useCheckoutStatus(): UseCheckoutStatusReturn;

package/lib/checkout/hooks/useCheckoutStatus.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCheckoutStatus = useCheckoutStatus;
+var _SessionContext = require("../context/SessionContext");
+function useCheckoutStatus() {
+  const {
+    isLoading,
+    error,
+    errorCode,
+    session,
+    isDonation
+  } = (0, _SessionContext.useSessionContext)();
+  const canSubmit = !isLoading && !error && session?.status === "open";
+  const isCompleted = session?.status === "complete";
+  const livemode = !!session?.livemode;
+  return {
+    isLoading,
+    error,
+    errorCode,
+    canSubmit,
+    isCompleted,
+    isDonation,
+    livemode
+  };
+}

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

@@ -0,0 +1,8 @@
+import type { TPrice } from '@blocklet/payment-types';
+export interface UseCrossSellReturn {
+    item: TPrice | null;
+    required: boolean;
+    add: () => Promise<void>;
+    remove: () => Promise<void>;
+}
+export declare function useCrossSell(): UseCrossSellReturn;