@blocklet/payment-react-headless 1.26.0

package/lib/checkout/hooks/usePricing.js

@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePricing = usePricing;
+var _react = require("react");
+var _ahooks = require("ahooks");
+var _checkoutAugmented = require("../../types/checkout-augmented");
+var _format = require("../../shared/format");
+var _exchangeRate = require("../core/exchangeRate");
+var _pricing = require("../core/pricing");
+var _promotion = require("../core/promotion");
+var _submit = require("../core/submit");
+function usePricing(sessionData, sessionId, currency, isStripe, refreshSession, paymentMethodType) {
+  const session = sessionData?.checkoutSession;
+  const items = session?.line_items || [];
+  const [exchangeRate, setExchangeRate] = (0, _react.useState)(null);
+  const [rateProvider, setRateProvider] = (0, _react.useState)(null);
+  const [rateProviderDisplay, setRateProviderDisplay] = (0, _react.useState)(null);
+  const [rateFetchedAt, setRateFetchedAt] = (0, _react.useState)(null);
+  const [rateStatus, setRateStatus] = (0, _react.useState)("loading");
+  const [promotionCode, setPromotionCode] = (0, _react.useState)(null);
+  (0, _react.useEffect)(() => {
+    if (!session || promotionCode) return;
+    const code = (0, _promotion.extractPromotionCodeFromSession)(session);
+    if (code) setPromotionCode(code);
+  }, [session?.id]);
+  const pollingRef = (0, _react.useRef)(null);
+  const failCountRef = (0, _react.useRef)(0);
+  const mountedRef = (0, _react.useRef)(true);
+  const hasDynamicPricing = (0, _react.useMemo)(() => (0, _exchangeRate.checkHasDynamicPricing)(items), [items]);
+  const fetchRate = (0, _ahooks.useMemoizedFn)(async () => {
+    if (!sessionId || !hasDynamicPricing || isStripe) {
+      setRateStatus(hasDynamicPricing ? "unavailable" : "available");
+      if (isStripe) {
+        setExchangeRate(null);
+        setRateProvider(null);
+        setRateProviderDisplay(null);
+        setRateFetchedAt(null);
+      }
+      return;
+    }
+    try {
+      setRateStatus("loading");
+      const result = await (0, _exchangeRate.fetchExchangeRate)(sessionId, currency?.id);
+      if (!mountedRef.current) return;
+      if (result.rate) {
+        setExchangeRate(result.rate);
+        setRateProvider(result.provider);
+        setRateProviderDisplay(result.providerDisplay);
+        setRateFetchedAt(result.fetchedAt);
+        setRateStatus("available");
+        failCountRef.current = 0;
+      } else {
+        setRateStatus("unavailable");
+      }
+    } catch {
+      if (!mountedRef.current) return;
+      failCountRef.current += 1;
+      setRateStatus("unavailable");
+    }
+  });
+  (0, _react.useEffect)(() => {
+    mountedRef.current = true;
+    if (!hasDynamicPricing || isStripe || !sessionId || session?.status === "complete") {
+      if (isStripe) {
+        setExchangeRate(null);
+        setRateProvider(null);
+        setRateProviderDisplay(null);
+        setRateFetchedAt(null);
+        setRateStatus("unavailable");
+      } else if (session?.status === "complete") {
+        setRateStatus("available");
+      }
+      return void 0;
+    }
+    fetchRate();
+    const scheduleNext = () => {
+      const backoff = (0, _exchangeRate.getBackoffInterval)(failCountRef.current);
+      pollingRef.current = setTimeout(() => {
+        fetchRate().then(scheduleNext);
+      }, backoff);
+    };
+    scheduleNext();
+    const handleVisibility = () => {
+      if (document.hidden) {
+        if (pollingRef.current) clearTimeout(pollingRef.current);
+      } else if (session?.status !== "complete") {
+        fetchRate().then(scheduleNext);
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibility);
+    return () => {
+      mountedRef.current = false;
+      if (pollingRef.current) clearTimeout(pollingRef.current);
+      document.removeEventListener("visibilitychange", handleVisibility);
+    };
+  }, [hasDynamicPricing, isStripe, sessionId, currency?.id, session?.status]);
+  const amounts = (0, _react.useMemo)(() => (0, _pricing.calculateAmounts)(items, currency, session, exchangeRate, hasDynamicPricing, paymentMethodType), [items, currency, exchangeRate, hasDynamicPricing, session, paymentMethodType]);
+  const quoteMeta = (0, _react.useMemo)(() => (0, _pricing.calculateQuoteMeta)(items, hasDynamicPricing, sessionData), [items, hasDynamicPricing, sessionData]);
+  const setSlippage = (0, _ahooks.useMemoizedFn)(async config => {
+    try {
+      const data = await (0, _submit.updateSlippage)(sessionId, config);
+      if (data?.checkoutSession || data?.quotes) {
+        await refreshSession(true);
+      }
+    } catch (err) {
+      console.error("Failed to update slippage:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  const currentSlippagePercent = quoteMeta.slippagePercent ?? 0.5;
+  (0, _react.useEffect)(() => {
+    if (!quoteMeta.expired || !quoteMeta.expiresAt || session?.status === "complete") return;
+    refreshSession(true);
+  }, [quoteMeta.expired]);
+  const applyPromotion = (0, _ahooks.useMemoizedFn)(async code => {
+    const result = await (0, _promotion.applyPromotionCode)(sessionId, code, currency?.id);
+    if (result.success) {
+      setPromotionCode(code);
+      await refreshSession(true);
+    }
+    return result;
+  });
+  const removePromotion = (0, _ahooks.useMemoizedFn)(async () => {
+    try {
+      await (0, _promotion.removePromotionCode)(sessionId);
+      setPromotionCode(null);
+      await refreshSession(true);
+    } catch {}
+  });
+  const promotionApplied = (session?.discounts || []).length > 0;
+  const promotionActive = (0, _promotion.isPromotionActive)(session);
+  const trial = (0, _pricing.calculateTrial)(session, currency?.id, items, currency, hasDynamicPricing, exchangeRate);
+  return {
+    ...amounts,
+    hasDynamicPricing,
+    rate: {
+      value: (0, _format.formatExchangeRate)(exchangeRate),
+      display: exchangeRate ? (0, _format.formatExchangeRateDisplay)(exchangeRate) : null,
+      provider: rateProvider,
+      providerDisplay: rateProviderDisplay,
+      fetchedAt: rateFetchedAt,
+      status: rateStatus,
+      refresh: fetchRate
+    },
+    quote: {
+      locked: quoteMeta.locked,
+      lockedAt: quoteMeta.lockedAt,
+      expiresAt: quoteMeta.expiresAt,
+      expired: quoteMeta.expired,
+      baseCurrency: quoteMeta.baseCurrency
+    },
+    slippage: {
+      percent: currentSlippagePercent,
+      set: setSlippage
+    },
+    promotion: {
+      applied: promotionApplied,
+      code: promotionCode,
+      active: promotionActive,
+      inactiveReason: !promotionActive ? "Promotions not allowed" : null,
+      apply: applyPromotion,
+      remove: removePromotion
+    },
+    trial
+  };
+}

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

@@ -0,0 +1,28 @@
+export interface UsePricingFeatureReturn {
+    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;
+    quote: {
+        locked: boolean;
+        lockedAt: number | null;
+        expiresAt: number | null;
+        expired: boolean;
+        baseCurrency: string | null;
+    };
+    trial: {
+        active: boolean;
+        days: number;
+        afterTrialPrice: string | null;
+        afterTrialInterval: string | null;
+    };
+}
+export declare function usePricingFeature(): UsePricingFeatureReturn;

package/lib/checkout/hooks/usePricingFeature.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePricingFeature = usePricingFeature;
+var _react = require("react");
+var _SessionContext = require("../context/SessionContext");
+var _PaymentMethodContext = require("../context/PaymentMethodContext");
+var _ExchangeRateContext = require("../context/ExchangeRateContext");
+var _pricing = require("../core/pricing");
+function usePricingFeature() {
+  const {
+    items,
+    session,
+    sessionData,
+    refresh
+  } = (0, _SessionContext.useSessionContext)();
+  const {
+    currency
+  } = (0, _PaymentMethodContext.usePaymentMethodContext)();
+  const {
+    rate: exchangeRate,
+    hasDynamicPricing
+  } = (0, _ExchangeRateContext.useExchangeRateContext)();
+  const {
+    current: currentMethod
+  } = (0, _PaymentMethodContext.usePaymentMethodContext)();
+  const amounts = (0, _react.useMemo)(() => (0, _pricing.calculateAmounts)(items, currency, session, exchangeRate, hasDynamicPricing, currentMethod?.type || null), [items, currency, exchangeRate, hasDynamicPricing, session, currentMethod?.type]);
+  const quoteMeta = (0, _react.useMemo)(() => (0, _pricing.calculateQuoteMeta)(items, hasDynamicPricing, sessionData), [items, hasDynamicPricing, sessionData]);
+  (0, _react.useEffect)(() => {
+    if (!quoteMeta.expired || !quoteMeta.expiresAt || session?.status === "complete") return;
+    refresh(true);
+  }, [quoteMeta.expired]);
+  const trial = (0, _pricing.calculateTrial)(session, currency?.id, items, currency, hasDynamicPricing, exchangeRate);
+  return {
+    ...amounts,
+    hasDynamicPricing,
+    quote: {
+      locked: quoteMeta.locked,
+      lockedAt: quoteMeta.lockedAt,
+      expiresAt: quoteMeta.expiresAt,
+      expired: quoteMeta.expired,
+      baseCurrency: quoteMeta.baseCurrency
+    },
+    trial
+  };
+}

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

@@ -0,0 +1,32 @@
+export interface UseProductReturn {
+    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;
+    vendorCount: number;
+}
+export declare function useProduct(): UseProductReturn;

package/lib/checkout/hooks/useProduct.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useProduct = useProduct;
+var _SessionContext = require("../context/SessionContext");
+function useProduct() {
+  const {
+    product,
+    subscription,
+    pageInfo,
+    vendorCount
+  } = (0, _SessionContext.useSessionContext)();
+  return {
+    product,
+    subscription,
+    pageInfo,
+    vendorCount
+  };
+}

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

@@ -0,0 +1,12 @@
+export interface UsePromotionReturn {
+    applied: boolean;
+    code: string | null;
+    active: boolean;
+    inactiveReason: string | null;
+    apply: (code: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    remove: () => Promise<void>;
+}
+export declare function usePromotion(): UsePromotionReturn;

package/lib/checkout/hooks/usePromotion.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePromotion = usePromotion;
+var _react = require("react");
+var _ahooks = require("ahooks");
+var _SessionContext = require("../context/SessionContext");
+var _PaymentMethodContext = require("../context/PaymentMethodContext");
+var _promotion = require("../core/promotion");
+function usePromotion() {
+  const {
+    session,
+    effectiveSessionId,
+    refresh
+  } = (0, _SessionContext.useSessionContext)();
+  const {
+    currency
+  } = (0, _PaymentMethodContext.usePaymentMethodContext)();
+  const [promotionCode, setPromotionCode] = (0, _react.useState)(null);
+  (0, _react.useEffect)(() => {
+    if (!session || promotionCode) return;
+    const code = (0, _promotion.extractPromotionCodeFromSession)(session);
+    if (code) setPromotionCode(code);
+  }, [session?.id]);
+  const apply = (0, _ahooks.useMemoizedFn)(async code => {
+    if (session?.status === "complete") return {
+      success: false,
+      error: "Session already completed"
+    };
+    const result = await (0, _promotion.applyPromotionCode)(effectiveSessionId, code, currency?.id);
+    if (result.success) {
+      setPromotionCode(code);
+      await refresh(true);
+    }
+    return result;
+  });
+  const remove = (0, _ahooks.useMemoizedFn)(async () => {
+    if (session?.status === "complete") return;
+    try {
+      await (0, _promotion.removePromotionCode)(effectiveSessionId);
+      setPromotionCode(null);
+      await refresh(true);
+    } catch {}
+  });
+  const promotionApplied = (session?.discounts || []).length > 0;
+  const promotionActive = (0, _promotion.isPromotionActive)(session);
+  return {
+    applied: promotionApplied,
+    code: promotionCode,
+    active: promotionActive,
+    inactiveReason: !promotionActive ? "Promotions not allowed" : null,
+    apply,
+    remove
+  };
+}

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

@@ -0,0 +1,8 @@
+export interface UseSlippageReturn {
+    percent: number;
+    set: (config: {
+        mode: string;
+        percent: number;
+    }) => Promise<void>;
+}
+export declare function useSlippage(): UseSlippageReturn;

package/lib/checkout/hooks/useSlippage.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSlippage = useSlippage;
+var _react = require("react");
+var _ahooks = require("ahooks");
+var _checkoutAugmented = require("../../types/checkout-augmented");
+var _SessionContext = require("../context/SessionContext");
+var _ExchangeRateContext = require("../context/ExchangeRateContext");
+var _pricing = require("../core/pricing");
+var _submit = require("../core/submit");
+function useSlippage() {
+  const {
+    items,
+    sessionData,
+    effectiveSessionId,
+    refresh
+  } = (0, _SessionContext.useSessionContext)();
+  const {
+    hasDynamicPricing
+  } = (0, _ExchangeRateContext.useExchangeRateContext)();
+  const quoteMeta = (0, _react.useMemo)(() => (0, _pricing.calculateQuoteMeta)(items, hasDynamicPricing, sessionData), [items, hasDynamicPricing, sessionData]);
+  const set = (0, _ahooks.useMemoizedFn)(async config => {
+    try {
+      const data = await (0, _submit.updateSlippage)(effectiveSessionId, config);
+      if (data?.checkoutSession || data?.quotes) {
+        await refresh(true);
+      }
+    } catch (err) {
+      console.error("Failed to update slippage:", (0, _checkoutAugmented.getErrorMessage)(err));
+    }
+  });
+  return {
+    percent: quoteMeta.slippagePercent ?? 0.5,
+    set
+  };
+}

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

@@ -0,0 +1,38 @@
+import type { SessionData } from './useCheckoutSession';
+import type { SubmitStatus, SubmitContext, CheckoutResult, CheckoutFormData } from '../types';
+export interface VendorStatus {
+    success: boolean;
+    status: 'delivered' | 'pending' | 'failed';
+    progress: number;
+    message: string;
+    appUrl?: string;
+    title?: string;
+    name?: string;
+    vendorType: string;
+}
+export interface VendorOrderStatus {
+    payment_status: string;
+    session_status: string;
+    vendors: VendorStatus[];
+    error: string | null;
+    isAllCompleted: boolean;
+    hasFailed: boolean;
+}
+export interface UseSubmitReturn {
+    status: SubmitStatus;
+    context: SubmitContext;
+    execute: () => Promise<void>;
+    confirm: () => Promise<void>;
+    cancel: () => void;
+    result: CheckoutResult | null;
+    retry: () => Promise<void>;
+    reset: () => void;
+    stripeConfirm: () => Promise<void>;
+    stripeCancel: () => Promise<void>;
+    vendorStatus: VendorOrderStatus | null;
+    /** Whether the checkout config is locked (user clicked "Connect and Pay", pending login/submit) */
+    locked: boolean;
+    /** Lock the checkout config — prevents quantity/currency/method changes */
+    lock: () => void;
+}
+export declare function useSubmit(sessionData: SessionData | null, sessionId: string, currencyId: string | null, isStripe: boolean, isCredit: boolean, isDonation: boolean, formValues: CheckoutFormData, validateForm: () => Promise<boolean>, refreshSession: (force?: boolean) => Promise<void>, updateSessionData?: (data: SessionData) => void): UseSubmitReturn;