@flopay/react 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1783 @@
+// src/provider.tsx
+import { useEffect, useState, useMemo } from "react";
+import { resolveBillingApiUrl } from "@flopay/shared";
+
+// src/context.ts
+import { createContext } from "react";
+var FloPayContext = createContext({
+  flopay: null,
+  elements: null,
+  billingApiUrl: ""
+});
+var CheckoutContext = createContext({
+  session: null,
+  loading: false,
+  error: null
+});
+
+// src/provider.tsx
+import { jsx } from "react/jsx-runtime";
+function FloPayProvider({
+  flopay: floPayProp,
+  options,
+  children
+}) {
+  const [flopay, setFloPay] = useState(
+    floPayProp instanceof Promise ? null : floPayProp
+  );
+  const [elements, setElements] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    if (floPayProp instanceof Promise) {
+      floPayProp.then((instance) => {
+        if (!cancelled) {
+          setFloPay(instance);
+        }
+      });
+    } else {
+      setFloPay(floPayProp);
+    }
+    return () => {
+      cancelled = true;
+    };
+  }, [floPayProp]);
+  useEffect(() => {
+    if (!flopay) {
+      setElements(null);
+      return;
+    }
+    const els = flopay.elements({
+      appearance: options?.appearance,
+      clientSecret: options?.clientSecret,
+      amount: options?.amount,
+      currency: options?.currency,
+      paymentMethodCreation: options?.paymentMethodCreation
+    });
+    setElements(els);
+    return () => {
+      els.destroy();
+    };
+  }, [flopay, options?.appearance, options?.clientSecret, options?.amount, options?.currency]);
+  const resolvedBillingApiUrl = resolveBillingApiUrl(options?.billingApiUrl);
+  const value = useMemo(
+    () => ({ flopay, elements, billingApiUrl: resolvedBillingApiUrl }),
+    [flopay, elements, resolvedBillingApiUrl]
+  );
+  return /* @__PURE__ */ jsx(FloPayContext.Provider, { value, children });
+}
+
+// src/flopay-checkout.tsx
+import React4, { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef3, useState as useState3 } from "react";
+import { loadFloPay, PaymentAPI } from "@flopay/js";
+import { FloPayError as FloPayError2, resolveBillingApiUrl as resolveBillingApiUrl3, buildCheckoutDisplayData } from "@flopay/shared";
+
+// src/elements.tsx
+import { useEffect as useEffect2, useRef, useContext } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function createElementComponent(elementType, displayName) {
+  function ElementComponent({
+    className,
+    id,
+    style,
+    options,
+    onChange,
+    onReady,
+    onFocus,
+    onBlur,
+    onEscape
+  }) {
+    const containerRef = useRef(null);
+    const elementRef = useRef(null);
+    const { elements } = useContext(FloPayContext);
+    useEffect2(() => {
+      if (!elements || !containerRef.current) return;
+      let mounted = true;
+      (async () => {
+        let element = elements.getElement(elementType);
+        if (!element) {
+          element = await elements.create(elementType, options);
+        }
+        if (!mounted || !containerRef.current) {
+          return;
+        }
+        element.mount(containerRef.current);
+        elementRef.current = element;
+        if (onChange) element.on("change", onChange);
+        if (onReady) element.on("ready", onReady);
+        if (onFocus) element.on("focus", onFocus);
+        if (onBlur) element.on("blur", onBlur);
+        if (onEscape) element.on("escape", onEscape);
+      })();
+      return () => {
+        mounted = false;
+        if (elementRef.current) {
+          try {
+            elementRef.current.unmount();
+          } catch {
+          }
+          elementRef.current = null;
+        }
+      };
+    }, [elements]);
+    return /* @__PURE__ */ jsx2("div", { ref: containerRef, className, id, style });
+  }
+  ElementComponent.displayName = displayName;
+  return ElementComponent;
+}
+var PaymentElement = createElementComponent("payment", "PaymentElement");
+var CardElement = createElementComponent("card", "CardElement");
+var CardNumberElement = createElementComponent("cardNumber", "CardNumberElement");
+var CardExpiryElement = createElementComponent("cardExpiry", "CardExpiryElement");
+var CardCvcElement = createElementComponent("cardCvc", "CardCvcElement");
+var AddressElement = createElementComponent("address", "AddressElement");
+
+// src/split-card-form.tsx
+import {
+  ExpressCheckoutElement,
+  Elements as StripeElements,
+  useElements as useStripeElements,
+  useStripe as useStripeRaw
+} from "@stripe/react-stripe-js";
+import { forwardRef, useCallback, useEffect as useEffect3, useImperativeHandle, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/hooks.ts
+import { useContext as useContext2 } from "react";
+import { resolveBillingApiUrl as resolveBillingApiUrl2 } from "@flopay/shared";
+function useFloPay() {
+  const ctx = useContext2(FloPayContext);
+  return ctx.flopay;
+}
+function useElements() {
+  const ctx = useContext2(FloPayContext);
+  return ctx.elements;
+}
+function useCheckout() {
+  return useContext2(CheckoutContext);
+}
+function useBillingApiUrl() {
+  const ctx = useContext2(FloPayContext);
+  return ctx.billingApiUrl || resolveBillingApiUrl2();
+}
+
+// src/split-card-form.tsx
+import { FloPayError } from "@flopay/shared";
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+var WALLET_RESUME_KEY = "flopay_wallet_resume";
+function ProcessingOverlay({ status }) {
+  return /* @__PURE__ */ jsx3("div", { style: {
+    position: "fixed",
+    inset: 0,
+    background: "rgba(0,0,0,0.35)",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    zIndex: 1e3,
+    backdropFilter: "blur(2px)"
+  }, children: /* @__PURE__ */ jsxs("div", { style: {
+    background: "white",
+    borderRadius: 12,
+    padding: "2rem 2.5rem",
+    textAlign: "center",
+    boxShadow: "0 8px 32px rgba(0,0,0,0.18)",
+    minWidth: 240,
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "center",
+    gap: 16
+  }, children: [
+    /* @__PURE__ */ jsxs("div", { style: { width: 48, height: 48, position: "relative" }, children: [
+      status === "processing" && /* @__PURE__ */ jsxs(
+        "svg",
+        {
+          width: "48",
+          height: "48",
+          viewBox: "0 0 24 24",
+          fill: "none",
+          xmlns: "http://www.w3.org/2000/svg",
+          style: { animation: "flopay-spin 0.8s linear infinite" },
+          children: [
+            /* @__PURE__ */ jsx3("circle", { cx: "12", cy: "12", r: "10", stroke: "#e5e7eb", strokeWidth: "3" }),
+            /* @__PURE__ */ jsx3("path", { d: "M4 12a8 8 0 018-8v3a5 5 0 00-5 5H4z", fill: "#4A49FF" })
+          ]
+        }
+      ),
+      status === "success" && /* @__PURE__ */ jsx3("div", { style: { animation: "flopay-pop 0.4s cubic-bezier(0.34,1.56,0.64,1)" }, children: /* @__PURE__ */ jsxs("svg", { width: "48", height: "48", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+        /* @__PURE__ */ jsx3("circle", { cx: "12", cy: "12", r: "11", fill: "#22c55e" }),
+        /* @__PURE__ */ jsx3(
+          "path",
+          {
+            d: "M7 12.5l3 3 7-7",
+            stroke: "white",
+            strokeWidth: "2.5",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            style: { strokeDasharray: 20, strokeDashoffset: 20, animation: "flopay-draw 0.4s 0.15s ease forwards" }
+          }
+        )
+      ] }) }),
+      status === "error" && /* @__PURE__ */ jsx3("div", { style: { animation: "flopay-shake 0.4s ease" }, children: /* @__PURE__ */ jsxs("svg", { width: "48", height: "48", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+        /* @__PURE__ */ jsx3("circle", { cx: "12", cy: "12", r: "11", fill: "#ef4444" }),
+        /* @__PURE__ */ jsx3(
+          "path",
+          {
+            d: "M8 8l8 8M16 8l-8 8",
+            stroke: "white",
+            strokeWidth: "2.5",
+            strokeLinecap: "round",
+            style: { strokeDasharray: 12, strokeDashoffset: 12, animation: "flopay-draw 0.3s 0.1s ease forwards" }
+          }
+        )
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsxs("span", { style: {
+      fontSize: 14,
+      fontWeight: 600,
+      letterSpacing: "0.05em",
+      color: status === "success" ? "#16a34a" : status === "error" ? "#dc2626" : "#374151"
+    }, children: [
+      status === "processing" && "PROCESSING...",
+      status === "success" && "PAYMENT SUCCESSFUL",
+      status === "error" && "PAYMENT FAILED"
+    ] }),
+    /* @__PURE__ */ jsx3("style", { children: `
+          @keyframes flopay-spin { to { transform: rotate(360deg); } }
+          @keyframes flopay-pop { 0% { transform: scale(0); } 100% { transform: scale(1); } }
+          @keyframes flopay-draw { to { stroke-dashoffset: 0; } }
+          @keyframes flopay-shake { 0%,100% { transform: translateX(0); } 20%,60% { transform: translateX(-4px); } 40%,80% { transform: translateX(4px); } }
+        ` })
+  ] }) });
+}
+var SplitCardForm = forwardRef(
+  function SplitCardForm2(props, ref) {
+    return /* @__PURE__ */ jsx3(SplitCardFormInner, { ...props, innerRef: ref });
+  }
+);
+function PayPalButtonInner({
+  sessionId,
+  email,
+  billingApiUrl,
+  onTokenizedBody,
+  onErrorChange,
+  isProcessing = false
+}) {
+  const stripe = useStripeRaw();
+  const elements = useStripeElements();
+  const [ready, setReady] = useState2(false);
+  const [submitting, setSubmitting] = useState2(false);
+  const paypalResumeAttempted = useRef2(false);
+  const baseUrl = billingApiUrl.replace(/\/+$/, "");
+  useEffect3(() => {
+    if (!stripe || paypalResumeAttempted.current) return;
+    const params = new URLSearchParams(window.location.search);
+    const paymentIntentId = params.get("payment_intent");
+    const clientSecret = params.get("payment_intent_client_secret");
+    const redirectStatus = params.get("redirect_status");
+    if (!paymentIntentId || !clientSecret) return;
+    paypalResumeAttempted.current = true;
+    (async () => {
+      try {
+        setSubmitting(true);
+        if (redirectStatus === "failed") {
+          onErrorChange?.("PayPal payment was declined. Please try again.");
+          return;
+        }
+        const { paymentIntent, error } = await stripe.retrievePaymentIntent(clientSecret);
+        if (error) {
+          onErrorChange?.(error.message ?? "Failed to retrieve PayPal payment status.");
+          return;
+        }
+        if (paymentIntent && (paymentIntent.status === "requires_capture" || paymentIntent.status === "succeeded")) {
+          const paymentMethodId = typeof paymentIntent.payment_method === "string" ? paymentIntent.payment_method : paymentIntent.payment_method?.id;
+          onTokenizedBody({
+            id: paymentMethodId ?? paymentIntent.id,
+            type: "card",
+            threeDSecureActionResultTokenId: paymentIntent.id,
+            isPaypal: true
+          });
+          const url = new URL(window.location.href);
+          url.searchParams.delete("payment_intent");
+          url.searchParams.delete("payment_intent_client_secret");
+          url.searchParams.delete("redirect_status");
+          window.history.replaceState({}, "", url.toString());
+        } else {
+          onErrorChange?.("PayPal payment was not completed. Please try again.");
+        }
+      } catch (err) {
+        onErrorChange?.(err instanceof Error ? err.message : "Failed to complete PayPal payment.");
+      } finally {
+        setSubmitting(false);
+      }
+    })();
+  }, [stripe, onTokenizedBody, onErrorChange]);
+  const handlePayPalConfirm = useCallback(async (_event) => {
+    if (!stripe || !elements) return;
+    try {
+      setSubmitting(true);
+      onErrorChange?.(null);
+      if (!sessionId || !email) {
+        throw new Error("Missing sessionId or email for PayPal payment");
+      }
+      const createPM = stripe.createPaymentMethod;
+      const { error: pmError, paymentMethod } = await createPM({ type: "paypal" });
+      if (pmError) {
+        console.warn("[FloPay] Could not create PayPal PM upfront:", pmError.message);
+      }
+      const intentResponse = await fetch(`${baseUrl}/v1/checkouts/payments/intents`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          sessionId,
+          email,
+          paymentMethodType: paymentMethod?.id ?? "paypal",
+          isPaypal: "true"
+        })
+      });
+      if (!intentResponse.ok) throw new Error("Failed to create payment intent");
+      const intentJson = await intentResponse.json();
+      const intentClientSecret = intentJson.data?.id;
+      if (!intentClientSecret) throw new Error("No client_secret in payment intent response");
+      const confirmParams = {
+        return_url: window.location.href
+      };
+      if (paymentMethod?.id) {
+        confirmParams["payment_method"] = paymentMethod.id;
+      }
+      const { error: confirmError, paymentIntent } = await stripe.confirmPayment({
+        clientSecret: intentClientSecret,
+        confirmParams,
+        redirect: "if_required"
+      });
+      if (confirmError) {
+        onErrorChange?.(confirmError.message ?? "PayPal payment failed.");
+        return;
+      }
+      const confirmedPmId = typeof paymentIntent?.payment_method === "string" ? paymentIntent.payment_method : paymentIntent?.payment_method?.id;
+      onTokenizedBody({
+        id: confirmedPmId ?? paymentIntent?.id,
+        type: "card",
+        threeDSecureActionResultTokenId: paymentIntent?.id,
+        isPaypal: true
+      });
+    } catch (err) {
+      onErrorChange?.(err instanceof Error ? err.message : "PayPal payment failed. Please try again.");
+    } finally {
+      setSubmitting(false);
+    }
+  }, [stripe, elements, sessionId, email, baseUrl, onTokenizedBody, onErrorChange]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx3("div", { style: { marginBottom: ready ? "0.5rem" : 0 }, children: /* @__PURE__ */ jsx3(
+      ExpressCheckoutElement,
+      {
+        onReady: () => setReady(true),
+        onLoadError: () => {
+        },
+        onConfirm: handlePayPalConfirm,
+        options: {
+          buttonType: { paypal: "paypal" },
+          paymentMethods: {
+            applePay: "never",
+            googlePay: "never",
+            paypal: "auto",
+            link: "never"
+          }
+        }
+      }
+    ) }),
+    submitting && /* @__PURE__ */ jsx3(ProcessingOverlay, { status: "processing" })
+  ] });
+}
+function WalletButtonInner({
+  sessionId,
+  email,
+  billingApiUrl,
+  showApplePay = true,
+  showGooglePay = true,
+  onTokenizedBody,
+  onErrorChange
+}) {
+  const stripe = useStripeRaw();
+  const elements = useStripeElements();
+  const [ready, setReady] = useState2(false);
+  const [submitting, setSubmitting] = useState2(false);
+  const baseUrl = billingApiUrl.replace(/\/+$/, "");
+  const handleWalletConfirm = useCallback(
+    async (_event) => {
+      if (!stripe || !elements) return;
+      try {
+        setSubmitting(true);
+        onErrorChange?.(null);
+        const { error: submitError } = await elements.submit();
+        if (submitError) {
+          onErrorChange?.(submitError.message ?? "Wallet payment failed.");
+          return;
+        }
+        const { error: pmError, paymentMethod } = await stripe.createPaymentMethod({ elements });
+        if (pmError || !paymentMethod) {
+          onErrorChange?.(pmError?.message ?? "Failed to create payment method.");
+          return;
+        }
+        if (!sessionId || !email) {
+          throw new Error("Missing sessionId or email for wallet payment");
+        }
+        const intentResponse = await fetch(`${baseUrl}/v1/checkouts/payments/intents`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            sessionId,
+            email,
+            paymentMethodType: paymentMethod.id,
+            isPaypal: false
+          })
+        });
+        if (!intentResponse.ok) throw new Error("Failed to create payment intent");
+        const intentJson = await intentResponse.json();
+        const intentClientSecret = intentJson.data?.id;
+        if (!intentClientSecret) throw new Error("No client_secret in payment intent response");
+        const { error: confirmError, paymentIntent } = await stripe.confirmCardPayment(
+          intentClientSecret,
+          { payment_method: paymentMethod.id }
+        );
+        if (confirmError) {
+          onErrorChange?.(confirmError.message ?? "Wallet payment failed.");
+          return;
+        }
+        onTokenizedBody({
+          id: paymentMethod.id,
+          type: "card",
+          threeDSecureActionResultTokenId: paymentIntent?.id
+        });
+      } catch (err) {
+        onErrorChange?.(err instanceof Error ? err.message : "Wallet payment failed. Please try again.");
+      } finally {
+        setSubmitting(false);
+      }
+    },
+    [stripe, elements, sessionId, email, baseUrl, onTokenizedBody, onErrorChange]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx3("div", { style: { marginBottom: ready ? "0.5rem" : 0 }, children: /* @__PURE__ */ jsx3(
+      ExpressCheckoutElement,
+      {
+        onReady: () => setReady(true),
+        onLoadError: () => {
+        },
+        onConfirm: handleWalletConfirm,
+        options: {
+          buttonType: { applePay: "plain", googlePay: "plain" },
+          paymentMethods: {
+            applePay: showApplePay ? "auto" : "never",
+            googlePay: showGooglePay ? "auto" : "never",
+            paypal: "never",
+            link: "never"
+          },
+          layout: { overflow: "never" }
+        }
+      }
+    ) }),
+    submitting && /* @__PURE__ */ jsx3(ProcessingOverlay, { status: "processing" })
+  ] });
+}
+function SplitCardFormInner({
+  sessionId,
+  billingApiUrl,
+  email,
+  userId,
+  onComplete,
+  onError,
+  onTokenizedBody,
+  firstName,
+  lastName,
+  chv,
+  submitLabel = "CONFIRM PAYMENT",
+  className,
+  children,
+  isProcessing: externalProcessing,
+  error: externalError,
+  onErrorChange,
+  onFirstNameChange,
+  onLastNameChange,
+  showPayPal = true,
+  showApplePay = true,
+  showGooglePay = true,
+  totalAmount = 0,
+  currency = "usd",
+  innerRef
+}) {
+  const flopay = useFloPay();
+  const elements = useElements();
+  const contextBillingUrl = useBillingApiUrl();
+  const [processing, setProcessing] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [is3DSActive, setIs3DSActive] = useState2(false);
+  const [fullName, setFullName] = useState2("");
+  const [formReady, setFormReady] = useState2(false);
+  const [overlayStatus, setOverlayStatus] = useState2(null);
+  const processingRef = useRef2(false);
+  const resolvedBillingApiUrl = billingApiUrl || contextBillingUrl;
+  const displayError = externalError ?? error;
+  const isSubmitting = externalProcessing ?? processing;
+  const isSelfContained = !onTokenizedBody;
+  const baseUrl = resolvedBillingApiUrl.replace(/\/+$/, "");
+  const stripeInstance = useMemo2(() => {
+    if (!flopay) return null;
+    return flopay.getRawProvider();
+  }, [flopay]);
+  const amountInCents = totalAmount || 100;
+  const walletOptions = useMemo2(() => ({
+    mode: "payment",
+    amount: amountInCents,
+    currency: currency.toLowerCase(),
+    paymentMethodCreation: "manual",
+    captureMethod: "manual"
+  }), [amountInCents, currency]);
+  const paypalOptions = useMemo2(() => ({
+    mode: "payment",
+    amount: amountInCents,
+    currency: currency.toLowerCase(),
+    captureMethod: "manual"
+  }), [amountInCents, currency]);
+  const updateError = useCallback(
+    (err) => {
+      setError(err);
+      onErrorChange?.(err);
+    },
+    [onErrorChange]
+  );
+  const showWallets = showApplePay || showGooglePay;
+  const handleNameChange = useCallback((value) => {
+    setFullName(value);
+    const parts = value.trim().split(/\s+/);
+    onFirstNameChange?.(parts[0] ?? "");
+    onLastNameChange?.(parts.length > 1 ? parts.slice(1).join(" ") : "");
+  }, [onFirstNameChange, onLastNameChange]);
+  const processPaymentInternal = useCallback(
+    async (tokenizedBody) => {
+      if (processingRef.current) return;
+      processingRef.current = true;
+      setProcessing(true);
+      setOverlayStatus("processing");
+      updateError(null);
+      try {
+        const response = await fetch(`${baseUrl}/v1/checkouts/sessions/process`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-user-id": userId ?? ""
+          },
+          body: JSON.stringify({
+            sessionId,
+            tokenizedData: tokenizedBody,
+            accountData: {
+              userId: userId ?? "",
+              email: email ?? "",
+              firstName: firstName ?? fullName.trim().split(/\s+/)[0] ?? "",
+              lastName: lastName ?? fullName.trim().split(/\s+/).slice(1).join(" ") ?? ""
+            },
+            chv
+          })
+        });
+        if (response.ok) {
+          setOverlayStatus("success");
+          await new Promise((r) => setTimeout(r, 1200));
+          onComplete?.({
+            status: "succeeded",
+            paymentIntentId: tokenizedBody.threeDSecureActionResultTokenId
+          });
+          return;
+        }
+        const json = await response.json().catch(() => null);
+        if (json?.type === "3ds_required") {
+          const secret = json["threeDSecureToken"];
+          if (!flopay || !secret) {
+            setOverlayStatus("error");
+            updateError("3DS authentication required but no token provided.");
+            return;
+          }
+          setIs3DSActive(true);
+          try {
+            const result = await flopay.confirmPayment({
+              clientSecret: secret,
+              returnUrl: window.location.href
+            });
+            if (result.error) {
+              setOverlayStatus("error");
+              updateError(result.error.message);
+              onError?.(result.error);
+              return;
+            }
+            if (result.status === "succeeded" || result.status === "processing") {
+              processingRef.current = false;
+              await processPaymentInternal({
+                id: result.paymentIntentId,
+                type: "card",
+                threeDSecureActionResultTokenId: result.paymentIntentId
+              });
+            }
+          } finally {
+            setIs3DSActive(false);
+          }
+          return;
+        }
+        if (json?.type === "paypal_redirect_required") {
+          const secret = json["threeDSecureToken"];
+          const savedPmId = json["paymentMethodId"] || tokenizedBody.id || "";
+          if (!flopay || !secret) {
+            setOverlayStatus("error");
+            updateError("PayPal authorization required but no token provided.");
+            return;
+          }
+          try {
+            const stripeInstance2 = flopay.getRawProvider();
+            if (!stripeInstance2) {
+              updateError("Payment provider not available.");
+              return;
+            }
+            const confirmParams = {
+              return_url: window.location.href
+            };
+            if (savedPmId) {
+              confirmParams["payment_method"] = savedPmId;
+            }
+            const { error: confirmError } = await stripeInstance2.confirmPayment({
+              clientSecret: secret,
+              confirmParams,
+              redirect: "if_required"
+            });
+            if (confirmError) {
+              setOverlayStatus("error");
+              updateError(confirmError.message ?? "PayPal payment failed.");
+            }
+          } catch (err) {
+            setOverlayStatus("error");
+            updateError(err instanceof Error ? err.message : "PayPal authorization failed.");
+          }
+          return;
+        }
+        setOverlayStatus("error");
+        updateError(json?.message ?? "Payment failed. Please try again.");
+        await new Promise((r) => setTimeout(r, 1500));
+      } catch (err) {
+        setOverlayStatus("error");
+        updateError(err instanceof Error ? err.message : "An unexpected error occurred");
+        await new Promise((r) => setTimeout(r, 1500));
+      } finally {
+        setProcessing(false);
+        setOverlayStatus(null);
+        processingRef.current = false;
+      }
+    },
+    [baseUrl, sessionId, userId, email, firstName, lastName, fullName, chv, flopay, onComplete, onError, updateError]
+  );
+  const dispatchTokenizedBody = useCallback(
+    (tokenizedBody) => {
+      if (onTokenizedBody) {
+        onTokenizedBody(tokenizedBody);
+      } else {
+        processPaymentInternal(tokenizedBody);
+      }
+    },
+    [onTokenizedBody, processPaymentInternal]
+  );
+  useImperativeHandle(innerRef, () => ({
+    async handleNextAction(secret) {
+      if (!flopay) return;
+      setIs3DSActive(true);
+      try {
+        const result = await flopay.confirmPayment({
+          clientSecret: secret,
+          returnUrl: window.location.href
+        });
+        if (result.error) {
+          updateError(result.error.message);
+          onError?.(result.error);
+        } else if (result.status === "succeeded" || result.status === "processing") {
+          dispatchTokenizedBody({
+            id: result.paymentIntentId,
+            type: "card",
+            threeDSecureActionResultTokenId: result.paymentIntentId
+          });
+        }
+      } catch (err) {
+        updateError(err instanceof Error ? err.message : "Payment authentication failed.");
+      } finally {
+        setIs3DSActive(false);
+      }
+    }
+  }), [flopay, dispatchTokenizedBody, onError, updateError]);
+  useEffect3(() => {
+    if (typeof window === "undefined") return;
+    const stored = localStorage.getItem(WALLET_RESUME_KEY);
+    if (!stored) return;
+    try {
+      const payload = JSON.parse(stored);
+      if (payload.sessionId === sessionId) {
+        localStorage.removeItem(WALLET_RESUME_KEY);
+        dispatchTokenizedBody({
+          id: payload.tokenId,
+          type: payload.tokenType,
+          threeDSecureActionResultTokenId: payload.paymentIntentId
+        });
+      }
+    } catch {
+      localStorage.removeItem(WALLET_RESUME_KEY);
+    }
+  }, [sessionId, dispatchTokenizedBody]);
+  const handleSubmit = useCallback(
+    async (e) => {
+      e.preventDefault();
+      if (!flopay || !elements || isSubmitting || processingRef.current) return;
+      setProcessing(true);
+      setOverlayStatus("processing");
+      updateError(null);
+      let handedOff = false;
+      try {
+        const submitResult = await flopay.submitElements();
+        if (submitResult.error) {
+          updateError(submitResult.error.message);
+          onError?.(submitResult.error);
+          return;
+        }
+        const pmResult = await flopay.createPaymentMethod();
+        if (pmResult.error || !pmResult.paymentMethodId) {
+          updateError(pmResult.error?.message ?? "Failed to create payment method.");
+          return;
+        }
+        if (!sessionId || !email) {
+          throw new FloPayError("Missing sessionId or email", "validation_error");
+        }
+        const intentResponse = await fetch(`${baseUrl}/v1/checkouts/payments/intents`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            sessionId,
+            email,
+            paymentMethodType: pmResult.paymentMethodId,
+            isPaypal: false
+          })
+        });
+        if (!intentResponse.ok) throw new FloPayError("Failed to create payment intent", "api_error");
+        const intentJson = await intentResponse.json();
+        const intentClientSecret = intentJson.data?.id;
+        if (!intentClientSecret) throw new FloPayError("No client_secret in payment intent response", "api_error");
+        const confirmResult = await flopay.confirmCardPayment({
+          clientSecret: intentClientSecret,
+          paymentMethodId: pmResult.paymentMethodId
+        });
+        if (confirmResult.error) {
+          setOverlayStatus("error");
+          updateError(confirmResult.error.message);
+          await new Promise((r) => setTimeout(r, 1500));
+          return;
+        }
+        handedOff = isSelfContained;
+        dispatchTokenizedBody({
+          id: pmResult.paymentMethodId,
+          type: "card",
+          threeDSecureActionResultTokenId: confirmResult.paymentIntentId
+        });
+      } catch (err) {
+        setOverlayStatus("error");
+        updateError(err instanceof Error ? err.message : "An unexpected error occurred");
+        await new Promise((r) => setTimeout(r, 1500));
+      } finally {
+        if (!handedOff) {
+          setProcessing(false);
+          setOverlayStatus(null);
+        }
+      }
+    },
+    [flopay, elements, isSubmitting, sessionId, email, baseUrl, isSelfContained, dispatchTokenizedBody, onError, updateError]
+  );
+  const isReady = flopay !== null && elements !== null;
+  if (!isReady) {
+    return /* @__PURE__ */ jsx3("div", { "data-testid": "flopay-loading", "aria-busy": "true", children: "Loading payment form..." });
+  }
+  return /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, className, style: { position: "relative" }, children: [
+    overlayStatus && /* @__PURE__ */ jsx3(ProcessingOverlay, { status: overlayStatus }),
+    showWallets && stripeInstance && /* @__PURE__ */ jsx3(StripeElements, { stripe: stripeInstance, options: walletOptions, children: /* @__PURE__ */ jsx3(
+      WalletButtonInner,
+      {
+        sessionId,
+        email,
+        billingApiUrl: resolvedBillingApiUrl,
+        showApplePay,
+        showGooglePay,
+        onTokenizedBody: dispatchTokenizedBody,
+        onErrorChange: updateError
+      }
+    ) }),
+    showPayPal && stripeInstance && /* @__PURE__ */ jsx3(StripeElements, { stripe: stripeInstance, options: paypalOptions, children: /* @__PURE__ */ jsx3(
+      PayPalButtonInner,
+      {
+        sessionId,
+        email,
+        billingApiUrl: resolvedBillingApiUrl,
+        onTokenizedBody: dispatchTokenizedBody,
+        onErrorChange: updateError,
+        isProcessing: isSubmitting
+      }
+    ) }),
+    (showWallets && stripeInstance || showPayPal && stripeInstance) && /* @__PURE__ */ jsxs("div", { style: {
+      display: "flex",
+      alignItems: "center",
+      gap: "0.75rem",
+      margin: "0.5rem 0 0.75rem",
+      color: "#999",
+      fontSize: "0.85rem"
+    }, children: [
+      /* @__PURE__ */ jsx3("div", { style: { flex: 1, height: 1, backgroundColor: "#ddd" } }),
+      /* @__PURE__ */ jsx3("span", { children: "or pay with card" }),
+      /* @__PURE__ */ jsx3("div", { style: { flex: 1, height: 1, backgroundColor: "#ddd" } })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { style: { backgroundColor: "#EDEDFF", borderRadius: "8px", padding: "1rem" }, children: [
+      /* @__PURE__ */ jsx3("div", { style: { textAlign: "center", fontWeight: 600, fontSize: "1.1rem", padding: "0.5rem 0", color: "#262833" }, children: "Secure card checkout" }),
+      /* @__PURE__ */ jsx3("div", { style: {
+        backgroundColor: "white",
+        border: "1px solid #A4A4FF",
+        borderTopLeftRadius: "8px",
+        borderTopRightRadius: "8px",
+        padding: "10px"
+      }, children: /* @__PURE__ */ jsx3(CardNumberElement, { onReady: () => setFormReady(true) }) }),
+      /* @__PURE__ */ jsxs("div", { style: { display: "flex" }, children: [
+        /* @__PURE__ */ jsx3("div", { style: {
+          flex: 1,
+          backgroundColor: "white",
+          border: "1px solid #A4A4FF",
+          borderTop: "none",
+          borderRight: "none",
+          borderBottomLeftRadius: "8px",
+          padding: "10px"
+        }, children: /* @__PURE__ */ jsx3(CardExpiryElement, {}) }),
+        /* @__PURE__ */ jsx3("div", { style: {
+          flex: 1,
+          backgroundColor: "white",
+          border: "1px solid #A4A4FF",
+          borderTop: "none",
+          borderBottomRightRadius: "8px",
+          padding: "10px"
+        }, children: /* @__PURE__ */ jsx3(CardCvcElement, {}) })
+      ] }),
+      /* @__PURE__ */ jsx3("div", { style: {
+        backgroundColor: "white",
+        border: "1px solid #A4A4FF",
+        borderRadius: "8px",
+        marginTop: "0.5rem",
+        padding: "10px"
+      }, children: /* @__PURE__ */ jsx3(
+        "input",
+        {
+          placeholder: "Full Name on Card",
+          autoComplete: "cc-name",
+          value: fullName,
+          onChange: (e) => handleNameChange(e.target.value),
+          disabled: isSubmitting,
+          required: true,
+          style: {
+            width: "100%",
+            border: "none",
+            outline: "none",
+            fontSize: "16px",
+            fontFamily: "Poppins, sans-serif",
+            color: "#262833"
+          }
+        }
+      ) }),
+      displayError && /* @__PURE__ */ jsx3("div", { role: "alert", "data-testid": "flopay-error", style: { color: "red", margin: "0.75rem 0", fontSize: "0.9rem" }, children: displayError }),
+      children ?? /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "submit",
+          disabled: !formReady || isSubmitting,
+          "data-testid": "flopay-submit",
+          style: {
+            width: "100%",
+            padding: "0.875rem",
+            marginTop: "1rem",
+            backgroundColor: "#4A49FF",
+            color: "white",
+            border: "none",
+            borderRadius: "8px",
+            fontSize: "1rem",
+            fontWeight: 600,
+            cursor: !formReady || isSubmitting ? "not-allowed" : "pointer",
+            opacity: !formReady || isSubmitting ? 0.5 : 1
+          },
+          children: isSubmitting ? "PROCESSING..." : submitLabel
+        }
+      ),
+      /* @__PURE__ */ jsx3("div", { style: {
+        backgroundColor: "#EFF9F0",
+        borderRadius: "8px",
+        padding: "0.75rem",
+        marginTop: "0.75rem",
+        textAlign: "center",
+        fontSize: "0.85rem",
+        fontWeight: 600,
+        color: "#7DAD3A"
+      }, children: "Secure Card Checkout" })
+    ] })
+  ] });
+}
+
+// src/flopay-checkout.tsx
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+function FloPayCheckout({
+  sessionId,
+  billingApiUrl,
+  appearance,
+  locale,
+  fallbackPublishableKey,
+  loading: loadingNode,
+  error: errorNode,
+  onComplete,
+  onError,
+  showPayPal = true,
+  showApplePay = true,
+  showGooglePay = true,
+  submitLabel,
+  className,
+  children,
+  checkoutMode: checkoutModeProp,
+  confirmLabel,
+  renderConfirmButton,
+  onSessionCompleted
+}) {
+  const resolvedBillingUrl = resolveBillingApiUrl3(billingApiUrl);
+  const [unified, setUnified] = useState3(null);
+  const [flopay, setFloPay] = useState3(null);
+  const flopayRef = useRef3(null);
+  const [session, setSession] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(true);
+  const [loadError, setLoadError] = useState3(null);
+  const [currentMode, setCurrentMode] = useState3("full");
+  const [confirmProcessing, setConfirmProcessing] = useState3(false);
+  const [modeError, setModeError] = useState3(null);
+  const autoCheckoutAttempted = useRef3(false);
+  const processPaymentForMode = useCallback2(
+    async (sess) => {
+      const baseUrl = resolvedBillingUrl.replace(/\/+$/, "");
+      const response = await fetch(`${baseUrl}/v1/checkouts/sessions/process`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-user-id": sess.customer?.id ?? ""
+        },
+        body: JSON.stringify({
+          sessionId,
+          tokenizedData: { id: void 0 },
+          accountData: {
+            userId: sess.customer?.id ?? "",
+            email: sess.customer?.email ?? "",
+            firstName: sess.customer?.firstName ?? "",
+            lastName: sess.customer?.lastName ?? ""
+          }
+        })
+      });
+      if (response.ok) {
+        onComplete?.({ status: "succeeded" });
+        return null;
+      }
+      const json = await response.json().catch(() => null);
+      if ((json?.type === "paypal_redirect_required" || json?.type === "3ds_required") && json?.threeDSecureToken) {
+        return {
+          type: json.type,
+          threeDSecureToken: json.threeDSecureToken,
+          paymentMethodId: json.paymentMethodId
+        };
+      }
+      throw new FloPayError2(
+        json?.message ?? "Payment failed. Please try again.",
+        "api_error"
+      );
+    },
+    [resolvedBillingUrl, sessionId, onComplete]
+  );
+  useEffect4(() => {
+    let cancelled = false;
+    setIsLoading(true);
+    setLoadError(null);
+    async function init() {
+      try {
+        const api = new PaymentAPI(resolvedBillingUrl);
+        const result = await api.getUnifiedCheckoutSession(sessionId);
+        if (cancelled) return;
+        setUnified(result);
+        const sess = result.data.session ?? null;
+        setSession(sess);
+        if (!sess) {
+          throw new FloPayError2("No session data returned", "api_error");
+        }
+        if (sess.status === "complete") {
+          setIsLoading(false);
+          onSessionCompleted?.(sess.successUrl ?? "");
+          return;
+        }
+        const effectiveMode = checkoutModeProp ?? sess.checkoutMode ?? "full";
+        setCurrentMode(effectiveMode);
+        const hasPayPalRedirectParams = typeof window !== "undefined" && new URLSearchParams(window.location.search).has("payment_intent");
+        if (effectiveMode === "auto" && !autoCheckoutAttempted.current && !hasPayPalRedirectParams) {
+          autoCheckoutAttempted.current = true;
+          const stripeInitPromise = initStripe(result, sess);
+          try {
+            const redirectResult = await processPaymentForMode(sess);
+            if (!redirectResult) {
+              if (!cancelled) setIsLoading(false);
+              return;
+            }
+            if (cancelled) return;
+            await stripeInitPromise;
+            if (redirectResult.type === "paypal_redirect_required") {
+              const stripeRef = flopayRef.current;
+              if (stripeRef) {
+                const rawStripe = stripeRef.getRawProvider();
+                if (rawStripe) {
+                  const confirmParams = {
+                    return_url: window.location.href
+                  };
+                  if (redirectResult.paymentMethodId) {
+                    confirmParams["payment_method"] = redirectResult.paymentMethodId;
+                  }
+                  await rawStripe.confirmPayment({
+                    clientSecret: redirectResult.threeDSecureToken,
+                    confirmParams,
+                    redirect: "if_required"
+                  });
+                  if (!cancelled) setIsLoading(false);
+                  return;
+                }
+              }
+            }
+            if (!cancelled) {
+              setCurrentMode("full");
+              setIsLoading(false);
+            }
+            return;
+          } catch {
+            if (cancelled) return;
+            setCurrentMode("full");
+            await stripeInitPromise;
+            if (!cancelled) setIsLoading(false);
+            return;
+          }
+        }
+        await initStripe(result, sess);
+        if (!cancelled) setIsLoading(false);
+      } catch (err) {
+        if (cancelled) return;
+        const floPayErr = err instanceof FloPayError2 ? err : new FloPayError2(
+          err instanceof Error ? err.message : "Failed to initialize checkout",
+          "api_error"
+        );
+        setLoadError(floPayErr);
+        setIsLoading(false);
+      }
+    }
+    async function initStripe(result, _sess) {
+      let publishableKey;
+      if (result.provider === "stripe") {
+        publishableKey = result.data.stripe?.publishableKey;
+      }
+      if (!publishableKey) publishableKey = fallbackPublishableKey;
+      if (!publishableKey) {
+        throw new FloPayError2(
+          "No publishable key found in session response. Provide a fallbackPublishableKey prop or ensure the session includes gatewayData.publishableKey.",
+          "validation_error"
+        );
+      }
+      const instance = await loadFloPay(publishableKey, {
+        billingApiUrl: resolvedBillingUrl,
+        locale
+      });
+      flopayRef.current = instance;
+      setFloPay(instance);
+    }
+    init();
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    sessionId,
+    resolvedBillingUrl,
+    fallbackPublishableKey,
+    locale,
+    checkoutModeProp,
+    onSessionCompleted,
+    processPaymentForMode
+  ]);
+  const handleConfirmCheckout = useCallback2(async () => {
+    if (confirmProcessing || !session) return;
+    setConfirmProcessing(true);
+    setModeError(null);
+    try {
+      await processPaymentForMode(session);
+    } catch (err) {
+      const floPayErr = err instanceof FloPayError2 ? err : new FloPayError2(
+        err instanceof Error ? err.message : "Payment failed",
+        "api_error"
+      );
+      setModeError(floPayErr.message);
+      onError?.(floPayErr);
+      setCurrentMode("full");
+    } finally {
+      setConfirmProcessing(false);
+    }
+  }, [confirmProcessing, session, processPaymentForMode, onError]);
+  const providerOptions = useMemo3(() => {
+    if (!unified || !session) return void 0;
+    const opts = {
+      appearance,
+      paymentMethodCreation: "manual",
+      billingApiUrl: resolvedBillingUrl
+    };
+    if (unified.provider === "stripe" && unified.data.stripe?.clientSecret) {
+      opts.clientSecret = unified.data.stripe.clientSecret;
+    } else {
+      const displayTotal = buildCheckoutDisplayData(session).total;
+      opts.amount = Math.round(displayTotal * 100) || session.amount;
+      opts.currency = session.currency?.toLowerCase();
+    }
+    return opts;
+  }, [unified, session, appearance, resolvedBillingUrl]);
+  const checkoutValue = useMemo3(
+    () => ({
+      session,
+      loading: isLoading,
+      error: loadError,
+      checkoutMode: currentMode
+    }),
+    [session, isLoading, loadError, currentMode]
+  );
+  if (isLoading) {
+    return /* @__PURE__ */ jsx4(Fragment2, { children: loadingNode ?? /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        style: {
+          display: "flex",
+          justifyContent: "center",
+          padding: 32
+        },
+        children: [
+          /* @__PURE__ */ jsx4(
+            "div",
+            {
+              style: {
+                width: 24,
+                height: 24,
+                border: "2px solid #e5e7eb",
+                borderTopColor: "#6b7280",
+                borderRadius: "50%",
+                animation: "spin 0.6s linear infinite"
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx4("style", { children: `@keyframes spin { to { transform: rotate(360deg); } }` })
+        ]
+      }
+    ) });
+  }
+  if (loadError) {
+    if (errorNode) return /* @__PURE__ */ jsx4(Fragment2, { children: errorNode(loadError) });
+    return /* @__PURE__ */ jsx4(
+      "div",
+      {
+        style: {
+          padding: 24,
+          textAlign: "center",
+          color: "#dc2626",
+          fontSize: 14
+        },
+        children: loadError.message
+      }
+    );
+  }
+  if (!flopay || !providerOptions) return /* @__PURE__ */ jsx4(Fragment2, {});
+  if (currentMode === "confirm") {
+    return /* @__PURE__ */ jsx4(CheckoutContext.Provider, { value: checkoutValue, children: /* @__PURE__ */ jsx4(FloPayProvider, { flopay, options: providerOptions, children: /* @__PURE__ */ jsxs2("div", { className, children: [
+      modeError && /* @__PURE__ */ jsx4(
+        "div",
+        {
+          style: {
+            color: "#dc2626",
+            fontSize: "0.875rem",
+            marginBottom: "0.75rem",
+            textAlign: "center"
+          },
+          children: modeError
+        }
+      ),
+      renderConfirmButton ? renderConfirmButton({
+        onConfirm: handleConfirmCheckout,
+        isProcessing: confirmProcessing
+      }) : /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          onClick: handleConfirmCheckout,
+          disabled: confirmProcessing,
+          style: {
+            width: "100%",
+            padding: "0.875rem",
+            backgroundColor: "#4A49FF",
+            color: "white",
+            border: "none",
+            borderRadius: "8px",
+            fontSize: "1rem",
+            fontWeight: 600,
+            cursor: confirmProcessing ? "not-allowed" : "pointer",
+            opacity: confirmProcessing ? 0.6 : 1
+          },
+          children: confirmProcessing ? "Processing..." : confirmLabel ?? "Confirm Purchase"
+        }
+      )
+    ] }) }) });
+  }
+  return /* @__PURE__ */ jsx4(CheckoutContext.Provider, { value: checkoutValue, children: /* @__PURE__ */ jsx4(FloPayProvider, { flopay, options: providerOptions, children: children ? /* @__PURE__ */ jsx4(
+    SessionInjector,
+    {
+      sessionId,
+      billingApiUrl: resolvedBillingUrl,
+      session,
+      children
+    }
+  ) : /* @__PURE__ */ jsx4(
+    SplitCardForm,
+    {
+      sessionId,
+      email: session?.customer?.email,
+      userId: session?.customer?.id,
+      firstName: session?.customer?.firstName,
+      lastName: session?.customer?.lastName,
+      totalAmount: session ? Math.round(buildCheckoutDisplayData(session).total * 100) : 0,
+      currency: session?.currency?.toLowerCase() ?? "usd",
+      onComplete,
+      onError,
+      showPayPal,
+      showApplePay,
+      showGooglePay,
+      submitLabel,
+      className
+    }
+  ) }) });
+}
+function SessionInjector({
+  sessionId,
+  billingApiUrl,
+  session,
+  children
+}) {
+  return /* @__PURE__ */ jsx4(Fragment2, { children: React4.Children.map(children, (child) => {
+    if (!React4.isValidElement(child)) return child;
+    const existing = child.props;
+    const injected = {};
+    if (!existing.sessionId) injected.sessionId = sessionId;
+    if (!existing.billingApiUrl) injected.billingApiUrl = billingApiUrl;
+    if (session?.customer) {
+      if (!existing.email) injected.email = session.customer.email;
+      if (!existing.userId) injected.userId = session.customer.id;
+      if (!existing.firstName)
+        injected.firstName = session.customer.firstName;
+      if (!existing.lastName)
+        injected.lastName = session.customer.lastName;
+    }
+    if (Object.keys(injected).length === 0) return child;
+    return React4.cloneElement(child, injected);
+  }) });
+}
+
+// src/checkout-form.tsx
+import { FloPayError as FloPayError3 } from "@flopay/shared";
+import { forwardRef as forwardRef2, useCallback as useCallback3, useEffect as useEffect5, useImperativeHandle as useImperativeHandle2, useState as useState4 } from "react";
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var WALLET_RESUME_KEY2 = "flopay_wallet_resume";
+var CheckoutForm = forwardRef2(
+  function CheckoutForm2(props, ref) {
+    return /* @__PURE__ */ jsx5(CheckoutFormInner, { ...props, innerRef: ref });
+  }
+);
+function CheckoutFormInner({
+  sessionId,
+  billingApiUrl,
+  email,
+  userId,
+  onComplete,
+  onError,
+  onTokenizedBody,
+  layout = "auto",
+  submitLabel = "Pay",
+  showAddress = false,
+  className,
+  children,
+  firstName,
+  lastName,
+  chv,
+  isProcessing: externalProcessing,
+  error: externalError,
+  onErrorChange,
+  innerRef
+}) {
+  const flopay = useFloPay();
+  const elements = useElements();
+  const contextBillingUrl = useBillingApiUrl();
+  const [processing, setProcessing] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [is3DSActive, setIs3DSActive] = useState4(false);
+  const displayError = externalError ?? error;
+  const isSubmitting = externalProcessing ?? processing;
+  const isSelfContained = !onTokenizedBody;
+  const baseUrl = (billingApiUrl || contextBillingUrl).replace(/\/+$/, "");
+  const updateError = useCallback3(
+    (err) => {
+      setError(err);
+      onErrorChange?.(err);
+    },
+    [onErrorChange]
+  );
+  const processPaymentInternal = useCallback3(
+    async (tokenizedBody) => {
+      setProcessing(true);
+      updateError(null);
+      try {
+        const response = await fetch(`${baseUrl}/v1/checkouts/sessions/process`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-user-id": userId ?? ""
+          },
+          body: JSON.stringify({
+            sessionId,
+            tokenizedData: tokenizedBody,
+            accountData: {
+              userId: userId ?? "",
+              email: email ?? "",
+              firstName: firstName ?? "",
+              lastName: lastName ?? ""
+            },
+            chv
+          })
+        });
+        if (response.ok) {
+          onComplete?.({
+            status: "succeeded",
+            paymentIntentId: tokenizedBody.threeDSecureActionResultTokenId
+          });
+          return;
+        }
+        const json = await response.json().catch(() => null);
+        if (json?.type === "3ds_required") {
+          const secret = json["threeDSecureToken"];
+          if (!flopay || !secret) {
+            updateError("3DS authentication required but no token provided.");
+            return;
+          }
+          setIs3DSActive(true);
+          try {
+            const result = await flopay.confirmPayment({
+              clientSecret: secret,
+              returnUrl: window.location.href
+            });
+            if (result.error) {
+              updateError(result.error.message);
+              onError?.(result.error);
+              return;
+            }
+            if (result.status === "succeeded" || result.status === "processing") {
+              await processPaymentInternal({
+                id: result.paymentIntentId,
+                type: "card",
+                threeDSecureActionResultTokenId: result.paymentIntentId
+              });
+            }
+          } finally {
+            setIs3DSActive(false);
+          }
+          return;
+        }
+        if (json?.type === "paypal_redirect_required") {
+          const secret = json["clientSecret"];
+          const pmId = json["paymentMethodId"];
+          if (flopay && secret) {
+            localStorage.setItem(WALLET_RESUME_KEY2, JSON.stringify({
+              sessionId,
+              paymentIntentId: "",
+              tokenType: "card",
+              tokenId: pmId,
+              status: "pending_redirect"
+            }));
+            await flopay.confirmPayment({
+              clientSecret: secret,
+              returnUrl: window.location.href
+            });
+          }
+          return;
+        }
+        const errorMessage = json?.message ?? "Payment failed. Please try again.";
+        updateError(errorMessage);
+      } catch (err) {
+        updateError(err instanceof Error ? err.message : "An unexpected error occurred");
+      } finally {
+        setProcessing(false);
+      }
+    },
+    [baseUrl, sessionId, userId, email, firstName, lastName, chv, flopay, onComplete, onError, updateError]
+  );
+  const dispatchTokenizedBody = useCallback3(
+    (tokenizedBody) => {
+      if (onTokenizedBody) {
+        onTokenizedBody(tokenizedBody);
+      } else {
+        processPaymentInternal(tokenizedBody);
+      }
+    },
+    [onTokenizedBody, processPaymentInternal]
+  );
+  useImperativeHandle2(innerRef, () => ({
+    async handleNextAction(secret) {
+      if (!flopay) return;
+      setIs3DSActive(true);
+      try {
+        const result = await flopay.confirmPayment({
+          clientSecret: secret,
+          returnUrl: window.location.href
+        });
+        if (result.error) {
+          updateError(result.error.message);
+          onError?.(result.error);
+        } else if (result.status === "succeeded" || result.status === "processing") {
+          dispatchTokenizedBody({
+            id: result.paymentIntentId,
+            type: "card",
+            threeDSecureActionResultTokenId: result.paymentIntentId
+          });
+        }
+      } catch (err) {
+        updateError(err instanceof Error ? err.message : "Payment authentication failed.");
+      } finally {
+        setIs3DSActive(false);
+      }
+    }
+  }), [flopay, dispatchTokenizedBody, onError, updateError]);
+  useEffect5(() => {
+    if (typeof window === "undefined") return;
+    const stored = localStorage.getItem(WALLET_RESUME_KEY2);
+    if (!stored) return;
+    try {
+      const payload = JSON.parse(stored);
+      if (payload.sessionId === sessionId) {
+        localStorage.removeItem(WALLET_RESUME_KEY2);
+        dispatchTokenizedBody({
+          id: payload.tokenId,
+          type: payload.tokenType,
+          threeDSecureActionResultTokenId: payload.paymentIntentId
+        });
+      }
+    } catch {
+      localStorage.removeItem(WALLET_RESUME_KEY2);
+    }
+  }, [sessionId, dispatchTokenizedBody]);
+  const handleSubmit = useCallback3(
+    async (e) => {
+      e.preventDefault();
+      if (!flopay || !elements || isSubmitting) return;
+      setProcessing(true);
+      updateError(null);
+      try {
+        const submitResult = await flopay.submitElements();
+        if (submitResult.error) {
+          updateError(submitResult.error.message);
+          onError?.(submitResult.error);
+          return;
+        }
+        const pmResult = await flopay.createPaymentMethod();
+        if (pmResult.error || !pmResult.paymentMethodId) {
+          updateError(pmResult.error?.message ?? "Failed to create payment method.");
+          return;
+        }
+        if (!sessionId || !email) {
+          throw new FloPayError3("Missing sessionId or email", "validation_error");
+        }
+        const intentResponse = await fetch(`${baseUrl}/v1/checkouts/payments/intents`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            sessionId,
+            email,
+            paymentMethodType: pmResult.paymentMethodId,
+            isPaypal: false
+          })
+        });
+        if (!intentResponse.ok) throw new FloPayError3("Failed to create payment intent", "api_error");
+        const intentJson = await intentResponse.json();
+        const intentClientSecret = intentJson.data?.id;
+        if (!intentClientSecret) throw new FloPayError3("No client_secret in payment intent response", "api_error");
+        const confirmResult = await flopay.confirmCardPayment({
+          clientSecret: intentClientSecret,
+          paymentMethodId: pmResult.paymentMethodId
+        });
+        if (confirmResult.error) {
+          updateError(confirmResult.error.message);
+          return;
+        }
+        dispatchTokenizedBody({
+          id: pmResult.paymentMethodId,
+          type: "card",
+          threeDSecureActionResultTokenId: confirmResult.paymentIntentId
+        });
+      } catch (err) {
+        updateError(err instanceof Error ? err.message : "An unexpected error occurred");
+      } finally {
+        if (isSelfContained) {
+        } else {
+          setProcessing(false);
+        }
+      }
+    },
+    [flopay, elements, isSubmitting, sessionId, email, baseUrl, isSelfContained, dispatchTokenizedBody, onError, updateError]
+  );
+  const isReady = flopay !== null && elements !== null;
+  return /* @__PURE__ */ jsxs3("form", { onSubmit: handleSubmit, className, style: { position: "relative" }, children: [
+    (is3DSActive || isSubmitting) && /* @__PURE__ */ jsx5("div", { "data-testid": "flopay-overlay", style: {
+      position: "absolute",
+      inset: 0,
+      background: "rgba(255,255,255,0.7)",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      zIndex: 10
+    }, children: is3DSActive ? "Verifying payment..." : "Processing..." }),
+    !isReady && /* @__PURE__ */ jsx5("div", { "data-testid": "flopay-loading", "aria-busy": "true", children: "Loading payment form..." }),
+    isReady && /* @__PURE__ */ jsxs3(Fragment3, { children: [
+      /* @__PURE__ */ jsx5(PaymentElement, { options: { layout } }),
+      showAddress && /* @__PURE__ */ jsx5(AddressElement, { options: { mode: showAddress === true ? "billing" : showAddress } }),
+      displayError && /* @__PURE__ */ jsx5("div", { role: "alert", "data-testid": "flopay-error", style: { color: "red", margin: "0.75rem 0" }, children: displayError }),
+      children ?? /* @__PURE__ */ jsx5(
+        "button",
+        {
+          type: "submit",
+          disabled: isSubmitting || !isReady,
+          "data-testid": "flopay-submit",
+          children: isSubmitting ? "Processing..." : submitLabel
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/paypal-button.tsx
+import { FloPayError as FloPayError4 } from "@flopay/shared";
+import { useCallback as useCallback4, useEffect as useEffect6, useRef as useRef4, useState as useState5 } from "react";
+import { Fragment as Fragment4, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function PayPalButton({
+  sessionId,
+  billingApiUrl,
+  email,
+  userId,
+  firstName,
+  lastName,
+  chv,
+  onTokenizedBody,
+  onComplete,
+  onErrorChange,
+  isProcessing = false
+}) {
+  const flopay = useFloPay();
+  const elements = useElements();
+  const contextBillingUrl = useBillingApiUrl();
+  const [ready, setReady] = useState5(false);
+  const [submitting, setSubmitting] = useState5(false);
+  const paypalResumeAttempted = useRef4(false);
+  const baseUrl = (billingApiUrl || contextBillingUrl).replace(/\/+$/, "");
+  const processPaymentInternal = useCallback4(
+    async (tokenizedBody) => {
+      try {
+        const response = await fetch(`${baseUrl}/v1/checkouts/sessions/process`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-user-id": userId ?? ""
+          },
+          body: JSON.stringify({
+            sessionId,
+            tokenizedData: tokenizedBody,
+            accountData: {
+              userId: userId ?? "",
+              email: email ?? "",
+              firstName: firstName ?? "",
+              lastName: lastName ?? ""
+            },
+            chv
+          })
+        });
+        if (response.ok) {
+          onComplete?.();
+          return;
+        }
+        const json = await response.json().catch(() => null);
+        onErrorChange?.(json?.message ?? "Payment failed. Please try again.");
+      } catch (err) {
+        onErrorChange?.(err instanceof Error ? err.message : "An unexpected error occurred");
+      }
+    },
+    [baseUrl, sessionId, userId, email, firstName, lastName, chv, onComplete, onErrorChange]
+  );
+  const dispatchTokenizedBody = useCallback4(
+    (body) => {
+      if (onTokenizedBody) {
+        onTokenizedBody(body);
+      } else {
+        processPaymentInternal(body);
+      }
+    },
+    [onTokenizedBody, processPaymentInternal]
+  );
+  useEffect6(() => {
+    if (!flopay || paypalResumeAttempted.current) return;
+    const params = new URLSearchParams(window.location.search);
+    const paymentIntentId = params.get("payment_intent");
+    const clientSecret = params.get("payment_intent_client_secret");
+    const redirectStatus = params.get("redirect_status");
+    if (!paymentIntentId || !clientSecret) return;
+    paypalResumeAttempted.current = true;
+    (async () => {
+      try {
+        setSubmitting(true);
+        if (redirectStatus === "failed") {
+          onErrorChange?.("PayPal payment was declined. Please try again.");
+          return;
+        }
+        const provider = flopay.getRawProvider();
+        if (!provider?.retrievePaymentIntent) {
+          onErrorChange?.("Cannot retrieve PayPal payment status.");
+          return;
+        }
+        const { paymentIntent, error: retrieveError } = await provider.retrievePaymentIntent(clientSecret);
+        if (retrieveError) {
+          onErrorChange?.(retrieveError.message ?? "Failed to retrieve PayPal payment status.");
+          return;
+        }
+        if (paymentIntent && (paymentIntent.status === "requires_capture" || paymentIntent.status === "succeeded")) {
+          const pmId = typeof paymentIntent.payment_method === "string" ? paymentIntent.payment_method : paymentIntent.payment_method?.id;
+          dispatchTokenizedBody({
+            id: pmId ?? paymentIntent.id,
+            type: "card",
+            threeDSecureActionResultTokenId: paymentIntent.id,
+            isPaypal: true
+          });
+          const url = new URL(window.location.href);
+          url.searchParams.delete("payment_intent");
+          url.searchParams.delete("payment_intent_client_secret");
+          url.searchParams.delete("redirect_status");
+          window.history.replaceState({}, "", url.toString());
+        } else {
+          onErrorChange?.("PayPal payment was not completed. Please try again.");
+        }
+      } catch (err) {
+        onErrorChange?.(err instanceof Error ? err.message : "Failed to complete PayPal payment.");
+      } finally {
+        setSubmitting(false);
+      }
+    })();
+  }, [flopay, dispatchTokenizedBody, onErrorChange]);
+  const handlePayPalConfirm = useCallback4(async () => {
+    if (!flopay || !elements) return;
+    try {
+      setSubmitting(true);
+      onErrorChange?.(null);
+      if (!sessionId || !email) {
+        throw new FloPayError4("Missing sessionId or email for PayPal payment", "validation_error");
+      }
+      const intentResponse = await fetch(`${baseUrl}/v1/checkouts/payments/intents`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          sessionId,
+          email,
+          paymentMethodType: "paypal",
+          isPaypal: "true"
+        })
+      });
+      if (!intentResponse.ok) throw new FloPayError4("Failed to create payment intent", "api_error");
+      const intentJson = await intentResponse.json();
+      const intentClientSecret = intentJson.data?.id;
+      if (!intentClientSecret) throw new FloPayError4("No client_secret in response", "api_error");
+      const result = await flopay.confirmPayment({
+        clientSecret: intentClientSecret,
+        returnUrl: window.location.href
+      });
+      if (result.status === "succeeded" || result.status === "processing") {
+        dispatchTokenizedBody({
+          id: result.paymentIntentId,
+          type: "card",
+          threeDSecureActionResultTokenId: result.paymentIntentId,
+          isPaypal: true
+        });
+      } else if (result.error) {
+        onErrorChange?.(result.error.message);
+      }
+    } catch (err) {
+      onErrorChange?.(err instanceof Error ? err.message : "PayPal payment failed. Please try again.");
+    } finally {
+      setSubmitting(false);
+    }
+  }, [flopay, elements, sessionId, email, baseUrl, dispatchTokenizedBody, onErrorChange]);
+  if (!flopay || !elements) {
+    return /* @__PURE__ */ jsx6("div", { style: { height: 45, background: "#f0f0f0", borderRadius: 6, animation: "pulse 1.5s infinite" } });
+  }
+  return /* @__PURE__ */ jsxs4(Fragment4, { children: [
+    !ready && /* @__PURE__ */ jsx6("div", { style: { height: 45, background: "#f0f0f0", borderRadius: 6 } }),
+    /* @__PURE__ */ jsx6("div", { style: ready ? {} : { display: "none" }, children: /* @__PURE__ */ jsx6(
+      "button",
+      {
+        type: "button",
+        onClick: handlePayPalConfirm,
+        disabled: submitting || isProcessing,
+        style: {
+          width: "100%",
+          height: 45,
+          backgroundColor: "#ffc439",
+          color: "#003087",
+          border: "none",
+          borderRadius: 6,
+          fontSize: "1rem",
+          fontWeight: 700,
+          cursor: submitting || isProcessing ? "not-allowed" : "pointer",
+          opacity: submitting || isProcessing ? 0.6 : 1
+        },
+        ref: () => setReady(true),
+        children: submitting ? "Processing..." : "PayPal"
+      }
+    ) }),
+    (submitting || isProcessing) && /* @__PURE__ */ jsx6("div", { style: {
+      position: "fixed",
+      inset: 0,
+      background: "rgba(0,0,0,0.4)",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      zIndex: 1e3
+    }, children: /* @__PURE__ */ jsx6("div", { style: {
+      background: "white",
+      borderRadius: 8,
+      padding: "1.5rem",
+      textAlign: "center",
+      boxShadow: "0 4px 24px rgba(0,0,0,0.15)",
+      width: 280
+    }, children: "Processing PayPal payment..." }) })
+  ] });
+}
+export {
+  AddressElement,
+  CardCvcElement,
+  CardElement,
+  CardExpiryElement,
+  CardNumberElement,
+  CheckoutForm,
+  FloPayCheckout,
+  FloPayProvider,
+  PayPalButton,
+  PaymentElement,
+  SplitCardForm,
+  useCheckout,
+  useElements,
+  useFloPay
+};
+//# sourceMappingURL=index.mjs.map