@blocklet/payment-react-headless 1.26.0

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

@@ -0,0 +1,40 @@
+import type { TCheckoutSessionExpanded } from '@blocklet/payment-types';
+import type { CheckoutFormData } from '../types';
+export declare const QUOTE_ERROR_CODES: readonly ["QUOTE_LOCK_EXPIRED", "QUOTE_AMOUNT_MISMATCH", "QUOTE_EXPIRED_OR_USED", "QUOTE_NOT_FOUND", "QUOTE_REQUIRED", "QUOTE_MAX_PAYABLE_EXCEEDED", "quote_validation_failed"];
+export declare const RELAY_SOCKET_PREFIX = "/.well-known/service/relay";
+export declare function getAppId(): string;
+export declare function getRelayChannel(token: string): string;
+export declare function getRelayProtocol(): string;
+export declare function getSocketHost(): string;
+/**
+ * Compute a fingerprint of the payment context for idempotency key stability.
+ * Key changes only when session state actually changes (quantity, upsell, currency).
+ * Same fingerprint → reuse Quote (intent: "retry with same Quote").
+ */
+export declare function getSessionFingerprint(session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null): string;
+export declare function buildSubmitPayload(sessionId: string, currencyId: string | null, formValues: CheckoutFormData, session: TCheckoutSessionExpanded | undefined | null, priceConfirmed?: boolean, idempotencyKey?: string): {
+    price_confirmed?: boolean | undefined;
+    idempotency_key: string;
+    preview_rate: string | undefined;
+    customer_name: string;
+    customer_email?: string;
+    customer_phone?: string;
+    payment_method: string;
+    payment_currency: string;
+    billing_address?: {
+        country: string;
+        state?: string;
+        city?: string;
+        line1?: string;
+        line2?: string;
+        postal_code: string;
+    };
+};
+export declare function isQuoteError(errorCode: string): boolean;
+export declare function abortStripePayment(sessionId: string): Promise<void>;
+export declare function submitCheckout(sessionId: string, isDonation: boolean, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function confirmFastCheckout(sessionId: string): Promise<Record<string, unknown>>;
+export declare function updateSlippage(sessionId: string, config: {
+    mode: string;
+    percent: number;
+}): Promise<Record<string, unknown>>;

package/es/checkout/core/submit.js

@@ -0,0 +1,66 @@
+import api, { API } from "../../shared/api.js";
+import { generateIdempotencyKey } from "../../shared/polling.js";
+export const QUOTE_ERROR_CODES = [
+  "QUOTE_LOCK_EXPIRED",
+  "QUOTE_AMOUNT_MISMATCH",
+  "QUOTE_EXPIRED_OR_USED",
+  "QUOTE_NOT_FOUND",
+  "QUOTE_REQUIRED",
+  "QUOTE_MAX_PAYABLE_EXCEEDED",
+  "quote_validation_failed"
+];
+export const RELAY_SOCKET_PREFIX = "/.well-known/service/relay";
+export function getAppId() {
+  const blocklet = window.blocklet;
+  return blocklet?.appPid || blocklet?.appId || "";
+}
+export function getRelayChannel(token) {
+  return `relay:${getAppId()}:${token}`;
+}
+export function getRelayProtocol() {
+  return window.location.protocol === "https:" ? "wss:" : "ws:";
+}
+export function getSocketHost() {
+  return new URL(window.location.href).host;
+}
+export function getSessionFingerprint(session, currencyId) {
+  if (!session) return "";
+  const items = session.line_items || [];
+  const sig = items.map((i) => `${i.upsell_price_id || i.price_id}:${i.quantity}`).join("|");
+  return `${session.id}-${currencyId}-${sig}`;
+}
+export function buildSubmitPayload(sessionId, currencyId, formValues, session, priceConfirmed = false, idempotencyKey) {
+  const lineItems = session?.line_items || [];
+  const matchedItem = lineItems.find((item) => item.exchange_rate);
+  const previewRate = matchedItem?.exchange_rate;
+  return {
+    ...formValues,
+    idempotency_key: idempotencyKey || generateIdempotencyKey(sessionId, currencyId || ""),
+    preview_rate: previewRate || void 0,
+    ...priceConfirmed && { price_confirmed: true }
+  };
+}
+export function isQuoteError(errorCode) {
+  return QUOTE_ERROR_CODES.includes(errorCode) || errorCode === "QUOTE_UPDATED";
+}
+export async function abortStripePayment(sessionId) {
+  try {
+    await api.post(API.ABORT_STRIPE(sessionId));
+  } catch {
+  }
+}
+export async function submitCheckout(sessionId, isDonation, payload) {
+  const url = isDonation ? API.DONATE_SUBMIT(sessionId) : API.SUBMIT(sessionId);
+  const { data } = await api.put(url, payload);
+  return data;
+}
+export async function confirmFastCheckout(sessionId) {
+  const { data } = await api.post(API.FAST_CHECKOUT_CONFIRM(sessionId), {});
+  return data;
+}
+export async function updateSlippage(sessionId, config) {
+  const { data } = await api.put(API.SLIPPAGE(sessionId), {
+    slippage_config: config
+  });
+  return data;
+}

package/es/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/es/checkout/hooks/index.js

@@ -0,0 +1,19 @@
+export { useCheckout } from "./useCheckout.js";
+export { useCheckoutSession } from "./useCheckoutSession.js";
+export { usePaymentMethod } from "./usePaymentMethod.js";
+export { usePricing } from "./usePricing.js";
+export { useCustomerForm } from "./useCustomerForm.js";
+export { useSubmit } from "./useSubmit.js";
+export { useProduct } from "./useProduct.js";
+export { useLineItems } from "./useLineItems.js";
+export { useBillingInterval } from "./useBillingInterval.js";
+export { useUpsell } from "./useUpsell.js";
+export { useCrossSell } from "./useCrossSell.js";
+export { usePromotion } from "./usePromotion.js";
+export { useExchangeRate } from "./useExchangeRate.js";
+export { useSlippage } from "./useSlippage.js";
+export { useCheckoutStatus } from "./useCheckoutStatus.js";
+export { usePricingFeature } from "./usePricingFeature.js";
+export { usePaymentMethodFeature } from "./usePaymentMethodFeature.js";
+export { useCustomerFormFeature } from "./useCustomerFormFeature.js";
+export { useSubmitFeature } from "./useSubmitFeature.js";

package/es/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/es/checkout/hooks/useBillingInterval.js

@@ -0,0 +1,50 @@
+import { useState, useMemo } from "react";
+import { useMemoizedFn } from "ahooks";
+import { getErrorMessage } from "../../types/checkout-augmented.js";
+import { useSessionContext } from "../context/SessionContext.js";
+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 { currency } = usePaymentMethodContext();
+  const currencyId = currency?.id || null;
+  const [switching, setSwitching] = useState(false);
+  const upsell = useMemoizedFn(async (fromId, toId) => {
+    try {
+      await performUpsell(effectiveSessionId, fromId, toId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to upsell:", getErrorMessage(err));
+    }
+  });
+  const downsell = useMemoizedFn(async (priceId) => {
+    try {
+      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to downsell:", getErrorMessage(err));
+    }
+  });
+  return useMemo(() => {
+    const parsed = 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/es/checkout/hooks/useCheckout.d.ts

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

package/es/checkout/hooks/useCheckout.js

@@ -0,0 +1,212 @@
+import { useMemo, useEffect, useRef, useState } from "react";
+import { useMemoizedFn } from "ahooks";
+import { getErrorMessage } from "../../types/checkout-augmented.js";
+import { useCheckoutSession } from "./useCheckoutSession.js";
+import { usePaymentMethod } from "./usePaymentMethod.js";
+import { usePricing } from "./usePricing.js";
+import { useCustomerForm } from "./useCustomerForm.js";
+import { useSubmit } from "./useSubmit.js";
+import {
+  recalculatePromotionIfNeeded,
+  adjustQuantity,
+  performUpsell,
+  performDownsell,
+  changeDonationAmount,
+  getCrossSellItem
+} from "../core/lineItems.js";
+import { addCrossSellItem, removeCrossSellItem, fetchCrossSellItem } from "../core/crossSell.js";
+import { parseBillingInterval } from "../core/billingInterval.js";
+export function useCheckout(sessionId) {
+  const {
+    isLoading,
+    error,
+    errorCode,
+    refresh,
+    sessionData,
+    resolvedSessionId,
+    vendorCount,
+    product,
+    subscription,
+    pageInfo
+  } = useCheckoutSession(sessionId);
+  const session = sessionData?.checkoutSession;
+  const effectiveSessionId = resolvedSessionId || sessionId;
+  const paymentMethodHook = usePaymentMethod(sessionData, effectiveSessionId, refresh);
+  const pricingHook = usePricing(
+    sessionData,
+    effectiveSessionId,
+    paymentMethodHook.currency,
+    paymentMethodHook.isStripe,
+    refresh,
+    paymentMethodHook.current?.type || null
+  );
+  const formHook = useCustomerForm(
+    sessionData,
+    paymentMethodHook.currency?.id || null,
+    paymentMethodHook.current?.id || null
+  );
+  const isDonation = session?.submit_type === "donate";
+  const submitHook = 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 = useRef(null);
+  useEffect(() => {
+    const currId = paymentMethodHook.currency?.id || null;
+    if (!currId || !session) return;
+    if (prevCurrencyRef.current === null || currId !== prevCurrencyRef.current) {
+      prevCurrencyRef.current = currId;
+      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then(() => refresh(true));
+    }
+  }, [paymentMethodHook.currency?.id, session?.id]);
+  const updateQuantity = useMemoizedFn(async (itemId, qty) => {
+    try {
+      await adjustQuantity(effectiveSessionId, itemId, qty, currencyId, session, refresh);
+    } 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);
+    } catch (err) {
+      console.error("Failed to upsell:", getErrorMessage(err));
+    }
+  });
+  const downsell = useMemoizedFn(async (priceId) => {
+    try {
+      await performDownsell(effectiveSessionId, priceId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to downsell:", getErrorMessage(err));
+    }
+  });
+  const embeddedCrossSellItem = useMemo(() => getCrossSellItem(items), [items]);
+  const [fetchedCrossSellItem, setFetchedCrossSellItem] = useState(null);
+  useEffect(() => {
+    if (!effectiveSessionId || !session) return void 0;
+    if (embeddedCrossSellItem) return void 0;
+    let cancelled = false;
+    fetchCrossSellItem(effectiveSessionId).then((item) => {
+      if (!cancelled && item) {
+        setFetchedCrossSellItem(item);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [effectiveSessionId, session?.id, embeddedCrossSellItem]);
+  const crossSellItem = embeddedCrossSellItem || fetchedCrossSellItem;
+  const crossSellRequired = useMemo(() => items.some((item) => item.cross_sell_required), [items]);
+  const addCrossSell = useMemoizedFn(async () => {
+    if (!crossSellItem) return;
+    try {
+      await addCrossSellItem(effectiveSessionId, crossSellItem.id, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to add cross-sell:", getErrorMessage(err));
+    }
+  });
+  const removeCrossSell = useMemoizedFn(async () => {
+    try {
+      await removeCrossSellItem(effectiveSessionId, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to remove cross-sell:", getErrorMessage(err));
+    }
+  });
+  const billingInterval = useMemo(() => {
+    const parsed = 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 = useMemoizedFn(async (priceId, amount) => {
+    if (!isDonation) return;
+    try {
+      await changeDonationAmount(effectiveSessionId, priceId, amount, session, currencyId, refresh);
+    } catch (err) {
+      console.error("Failed to change amount:", 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/es/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/es/checkout/hooks/useCheckoutSession.js

@@ -0,0 +1,107 @@
+import { useState, useCallback, useRef, useEffect } from "react";
+import { useMemoizedFn } from "ahooks";
+import api, { API } from "../../shared/api.js";
+import { getAxiosErrorDetails } from "../../types/checkout-augmented.js";
+import { parseProduct, parseSubscription, parsePageInfo } from "../core/session.js";
+export function useCheckoutSession(sessionId) {
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [sessionData, setSessionData] = useState(null);
+  const abortRef = useRef(null);
+  const mountedRef = useRef(true);
+  const resolvedIdRef = useRef(null);
+  const isPaymentLink = sessionId?.startsWith("plink_");
+  const resolveSessionId = useMemoizedFn(async () => {
+    if (!isPaymentLink) return sessionId;
+    if (resolvedIdRef.current) return resolvedIdRef.current;
+    const { data } = await api.post(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 = 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.RETRIEVE_SESSION(realId)}?forceRefresh=1` : API.RETRIEVE_SESSION(realId);
+      const { data } = await api.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 } = getAxiosErrorDetails(err);
+      if (isCancelled) return;
+      setError(message || "Failed to load checkout session");
+      setIsLoading(false);
+    }
+  });
+  const refresh = useCallback(
+    async (forceRefresh = false) => {
+      await fetchSession(forceRefresh);
+    },
+    [fetchSession]
+  );
+  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 ? parseProduct(session) : null,
+    subscription: session ? parseSubscription(session) : null,
+    pageInfo: session ? parsePageInfo(session) : null
+  };
+}

package/es/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/es/checkout/hooks/useCheckoutStatus.js

@@ -0,0 +1,16 @@
+import { useSessionContext } from "../context/SessionContext.js";
+export function useCheckoutStatus() {
+  const { isLoading, error, errorCode, session, isDonation } = 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/es/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;