@solvapay/react 1.0.0-preview.2 → 1.0.0-preview.20

package/dist/index.js

@@ -1,194 +1,668 @@
+import {
+  defaultAuthAdapter
+} from "./chunk-OUSEQRCT.js";
+
 // src/SolvaPayProvider.tsx
-import { useState, useEffect } from "react";
-import { Elements } from "@stripe/react-stripe-js";
-import { loadStripe } from "@stripe/stripe-js";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { createContext, useState, useEffect, useCallback, useMemo, useRef } from "react";
+
+// src/utils/purchases.ts
+function filterPurchases(purchases) {
+  return purchases.filter((purchase) => purchase.status === "active");
+}
+function getActivePurchases(purchases) {
+  return purchases.filter((purchase) => purchase.status === "active");
+}
+function getCancelledPurchasesWithEndDate(purchases) {
+  const now = /* @__PURE__ */ new Date();
+  return purchases.filter((purchase) => {
+    return purchase.status === "active" && purchase.cancelledAt && purchase.endDate && new Date(purchase.endDate) > now;
+  });
+}
+function getMostRecentPurchase(purchases) {
+  if (purchases.length === 0) return null;
+  return purchases.reduce((latest, current) => {
+    return new Date(current.startDate) > new Date(latest.startDate) ? current : latest;
+  });
+}
+function getPrimaryPurchase(purchases) {
+  const filtered = filterPurchases(purchases);
+  if (filtered.length > 0) {
+    return getMostRecentPurchase(filtered);
+  }
+  return null;
+}
+function isPaidPurchase(purchase) {
+  return (purchase.amount ?? 0) > 0;
+}
+
+// src/SolvaPayProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var SolvaPayContext = createContext(null);
+var CUSTOMER_REF_KEY = "solvapay_customerRef";
+var CUSTOMER_REF_EXPIRY = "solvapay_customerRef_expiry";
+var CUSTOMER_REF_USER_ID_KEY = "solvapay_customerRef_userId";
+var CACHE_DURATION = 24 * 60 * 60 * 1e3;
+function getCachedCustomerRef(userId) {
+  if (typeof window === "undefined") return null;
+  const cached = localStorage.getItem(CUSTOMER_REF_KEY);
+  const expiry = localStorage.getItem(CUSTOMER_REF_EXPIRY);
+  const cachedUserId = localStorage.getItem(CUSTOMER_REF_USER_ID_KEY);
+  if (!cached || !expiry) return null;
+  if (Date.now() > parseInt(expiry)) {
+    localStorage.removeItem(CUSTOMER_REF_KEY);
+    localStorage.removeItem(CUSTOMER_REF_EXPIRY);
+    localStorage.removeItem(CUSTOMER_REF_USER_ID_KEY);
+    return null;
+  }
+  if (userId !== void 0 && userId !== null) {
+    if (cachedUserId !== userId) {
+      clearCachedCustomerRef();
+      return null;
+    }
+  }
+  return cached;
+}
+function setCachedCustomerRef(customerRef, userId) {
+  if (typeof window === "undefined") return;
+  if (userId === void 0 || userId === null) {
+    return;
+  }
+  localStorage.setItem(CUSTOMER_REF_KEY, customerRef);
+  localStorage.setItem(CUSTOMER_REF_EXPIRY, String(Date.now() + CACHE_DURATION));
+  localStorage.setItem(CUSTOMER_REF_USER_ID_KEY, userId);
+}
+function clearCachedCustomerRef() {
+  if (typeof window === "undefined") return;
+  localStorage.removeItem(CUSTOMER_REF_KEY);
+  localStorage.removeItem(CUSTOMER_REF_EXPIRY);
+  localStorage.removeItem(CUSTOMER_REF_USER_ID_KEY);
+}
+function getAuthAdapter(config) {
+  if (config?.auth?.adapter) {
+    return config.auth.adapter;
+  }
+  if (config?.auth?.getToken || config?.auth?.getUserId) {
+    return {
+      async getToken() {
+        return config?.auth?.getToken?.() || null;
+      },
+      async getUserId() {
+        return config?.auth?.getUserId?.() || null;
+      }
+    };
+  }
+  return defaultAuthAdapter;
+}
 var SolvaPayProvider = ({
-  children,
-  amount = 999,
-  // Default $9.99
-  currency = "USD",
-  planRef,
-  agentRef,
-  apiBaseUrl = "/api/solvapay",
-  onPaymentReady
+  config,
+  createPayment: customCreatePayment,
+  checkPurchase: customCheckPurchase,
+  processPayment: customProcessPayment,
+  children
 }) => {
-  const [stripePromise, setStripePromise] = useState(null);
-  const [clientSecret, setClientSecret] = useState("");
+  const [purchaseData, setPurchaseData] = useState({
+    purchases: []
+  });
   const [loading, setLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const createPayment = async (paymentAmount) => {
-    setLoading(true);
-    setError(null);
-    try {
-      console.log("Creating SolvaPay payment intent for amount:", paymentAmount);
-      const response = await fetch(`${apiBaseUrl}/create-payment-intent`, {
+  const [internalCustomerRef, setInternalCustomerRef] = useState(void 0);
+  const [userId, setUserId] = useState(null);
+  const [isAuthenticated, setIsAuthenticated] = useState(false);
+  const inFlightRef = useRef(null);
+  const lastFetchedRef = useRef(null);
+  const checkPurchaseRef = useRef(null);
+  const createPaymentRef = useRef(null);
+  const processPaymentRef = useRef(null);
+  const configRef = useRef(config);
+  const buildDefaultCheckPurchaseRef = useRef(
+    null
+  );
+  useEffect(() => {
+    configRef.current = config;
+  }, [config]);
+  useEffect(() => {
+    checkPurchaseRef.current = customCheckPurchase || null;
+  }, [customCheckPurchase]);
+  useEffect(() => {
+    createPaymentRef.current = customCreatePayment || null;
+  }, [customCreatePayment]);
+  useEffect(() => {
+    processPaymentRef.current = customProcessPayment || null;
+  }, [customProcessPayment]);
+  const buildDefaultCheckPurchase = useCallback(async () => {
+    const currentConfig = configRef.current;
+    const adapter = getAuthAdapter(currentConfig);
+    const token = await adapter.getToken();
+    const detectedUserId = await adapter.getUserId();
+    const route = currentConfig?.api?.checkPurchase || "/api/check-purchase";
+    const fetchFn = currentConfig?.fetch || fetch;
+    const cachedRef = getCachedCustomerRef(detectedUserId);
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (cachedRef) {
+      headers["x-solvapay-customer-ref"] = cachedRef;
+    }
+    if (currentConfig?.headers) {
+      const customHeaders = typeof currentConfig.headers === "function" ? await currentConfig.headers() : currentConfig.headers;
+      Object.assign(headers, customHeaders);
+    }
+    const res = await fetchFn(route, {
+      method: "GET",
+      headers
+    });
+    if (!res.ok) {
+      const error = new Error(`Failed to check purchase: ${res.statusText}`);
+      currentConfig?.onError?.(error, "checkPurchase");
+      throw error;
+    }
+    return res.json();
+  }, []);
+  useEffect(() => {
+    buildDefaultCheckPurchaseRef.current = buildDefaultCheckPurchase;
+  }, [buildDefaultCheckPurchase]);
+  const buildDefaultCreatePayment = useCallback(
+    async (params) => {
+      const currentConfig = configRef.current;
+      const adapter = getAuthAdapter(currentConfig);
+      const token = await adapter.getToken();
+      const detectedUserId = await adapter.getUserId();
+      const route = currentConfig?.api?.createPayment || "/api/create-payment-intent";
+      const fetchFn = currentConfig?.fetch || fetch;
+      const cachedRef = getCachedCustomerRef(detectedUserId);
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+      if (cachedRef) {
+        headers["x-solvapay-customer-ref"] = cachedRef;
+      }
+      if (currentConfig?.headers) {
+        const customHeaders = typeof currentConfig.headers === "function" ? await currentConfig.headers() : currentConfig.headers;
+        Object.assign(headers, customHeaders);
+      }
+      const body = { planRef: params.planRef };
+      if (params.productRef) {
+        body.productRef = params.productRef;
+      }
+      const res = await fetchFn(route, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          planRef,
-          agentRef,
-          amount: paymentAmount,
-          currency,
-          description: "SolvaPay - Plan Purchase"
-        })
+        headers,
+        body: JSON.stringify(body)
       });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Payment intent creation failed: ${response.status} ${errorText}`);
-      }
-      const result = await response.json();
-      if (!result || !result.clientSecret || !result.publishableKey) {
-        throw new Error("Invalid response from server: missing required fields");
-      }
-      console.log("Payment intent received:", {
-        hasClientSecret: !!result.clientSecret,
-        hasPublishableKey: !!result.publishableKey,
-        hasAccountId: !!result.accountId,
-        clientSecretLength: result.clientSecret?.length || 0,
-        publishableKeyLength: result.publishableKey?.length || 0
+      if (!res.ok) {
+        const error = new Error(`Failed to create payment: ${res.statusText}`);
+        currentConfig?.onError?.(error, "createPayment");
+        throw error;
+      }
+      return res.json();
+    },
+    []
+  );
+  const buildDefaultProcessPayment = useCallback(
+    async (params) => {
+      const currentConfig = configRef.current;
+      const adapter = getAuthAdapter(currentConfig);
+      const token = await adapter.getToken();
+      const detectedUserId = await adapter.getUserId();
+      const route = currentConfig?.api?.processPayment || "/api/process-payment";
+      const fetchFn = currentConfig?.fetch || fetch;
+      const cachedRef = getCachedCustomerRef(detectedUserId);
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+      if (cachedRef) {
+        headers["x-solvapay-customer-ref"] = cachedRef;
+      }
+      if (currentConfig?.headers) {
+        const customHeaders = typeof currentConfig.headers === "function" ? await currentConfig.headers() : currentConfig.headers;
+        Object.assign(headers, customHeaders);
+      }
+      const res = await fetchFn(route, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
       });
+      if (!res.ok) {
+        const error = new Error(`Failed to process payment: ${res.statusText}`);
+        currentConfig?.onError?.(error, "processPayment");
+        throw error;
+      }
+      return res.json();
+    },
+    []
+  );
+  const _checkPurchase = useCallback(async () => {
+    if (checkPurchaseRef.current) {
+      return checkPurchaseRef.current();
+    }
+    if (buildDefaultCheckPurchaseRef.current) {
+      return buildDefaultCheckPurchaseRef.current();
+    }
+    return buildDefaultCheckPurchase();
+  }, [buildDefaultCheckPurchase]);
+  const createPayment = useCallback(
+    async (params) => {
+      if (createPaymentRef.current) {
+        return createPaymentRef.current(params);
+      }
+      return buildDefaultCreatePayment(params);
+    },
+    [buildDefaultCreatePayment]
+  );
+  const processPayment = useCallback(
+    async (params) => {
+      if (processPaymentRef.current) {
+        return processPaymentRef.current(params);
+      }
+      return buildDefaultProcessPayment(params);
+    },
+    [buildDefaultProcessPayment]
+  );
+  useEffect(() => {
+    const detectAuth = async () => {
+      const currentConfig = configRef.current;
+      const adapter = getAuthAdapter(currentConfig);
+      const token = await adapter.getToken();
+      const detectedUserId = await adapter.getUserId();
+      const prevUserId = userId;
+      setIsAuthenticated(!!token);
+      setUserId(detectedUserId);
+      if (prevUserId !== null && detectedUserId !== prevUserId) {
+        clearCachedCustomerRef();
+        setInternalCustomerRef(void 0);
+        return;
+      }
+      const cachedRef = getCachedCustomerRef(detectedUserId);
+      if (cachedRef && token) {
+        setInternalCustomerRef(cachedRef);
+      } else if (!token) {
+        clearCachedCustomerRef();
+        setInternalCustomerRef(void 0);
+      } else if (token && !cachedRef) {
+        setInternalCustomerRef(void 0);
+      }
+    };
+    detectAuth();
+    const interval = setInterval(detectAuth, 5e3);
+    return () => clearInterval(interval);
+  }, [userId]);
+  const fetchPurchase = useCallback(
+    async (force = false) => {
+      if (!isAuthenticated && !internalCustomerRef) {
+        setPurchaseData({ purchases: [] });
+        setLoading(false);
+        inFlightRef.current = null;
+        lastFetchedRef.current = null;
+        return;
+      }
+      const cacheKey = internalCustomerRef || userId || "anonymous";
+      if (!force && lastFetchedRef.current === cacheKey && inFlightRef.current !== cacheKey) {
+        return;
+      }
+      if (inFlightRef.current === cacheKey) {
+        return;
+      }
+      inFlightRef.current = cacheKey;
+      setLoading(true);
+      try {
+        const checkFn = checkPurchaseRef.current || buildDefaultCheckPurchaseRef.current;
+        if (!checkFn) {
+          throw new Error("checkPurchase function not available");
+        }
+        const data = await checkFn();
+        if (data.customerRef) {
+          setInternalCustomerRef(data.customerRef);
+          const currentAdapter = getAuthAdapter(configRef.current);
+          const currentUserId = await currentAdapter.getUserId();
+          setCachedCustomerRef(data.customerRef, currentUserId);
+        }
+        if (inFlightRef.current === cacheKey) {
+          const filteredData = {
+            ...data,
+            purchases: filterPurchases(data.purchases || [])
+          };
+          setPurchaseData(filteredData);
+          lastFetchedRef.current = cacheKey;
+        }
+      } catch (error) {
+        console.error("[SolvaPayProvider] Failed to fetch purchase:", error);
+        if (inFlightRef.current === cacheKey) {
+          setPurchaseData({
+            purchases: []
+          });
+          lastFetchedRef.current = cacheKey;
+        }
+      } finally {
+        if (inFlightRef.current === cacheKey) {
+          setLoading(false);
+          inFlightRef.current = null;
+        }
+      }
+    },
+    [isAuthenticated, internalCustomerRef, userId]
+  );
+  const fetchPurchaseRef = useRef(fetchPurchase);
+  useEffect(() => {
+    fetchPurchaseRef.current = fetchPurchase;
+  }, [fetchPurchase]);
+  const refetchPurchase = useCallback(async () => {
+    lastFetchedRef.current = null;
+    inFlightRef.current = null;
+    setPurchaseData({ purchases: [] });
+    await fetchPurchaseRef.current(true);
+  }, []);
+  useEffect(() => {
+    lastFetchedRef.current = null;
+    inFlightRef.current = null;
+    if (isAuthenticated || internalCustomerRef) {
+      fetchPurchase();
+    } else {
+      setPurchaseData({ purchases: [] });
+      setLoading(false);
+    }
+  }, [isAuthenticated, internalCustomerRef, userId]);
+  const updateCustomerRef = useCallback(
+    (newCustomerRef) => {
+      setInternalCustomerRef(newCustomerRef);
+      setCachedCustomerRef(newCustomerRef, userId);
+      fetchPurchase(true);
+    },
+    [fetchPurchase, userId]
+  );
+  const purchase = useMemo(() => {
+    const activePurchase = getPrimaryPurchase(purchaseData.purchases);
+    const activePaidPurchases = purchaseData.purchases.filter(
+      (p) => p.status === "active" && isPaidPurchase(p)
+    );
+    const activePaidPurchase = activePaidPurchases.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
+    return {
+      loading,
+      customerRef: purchaseData.customerRef || internalCustomerRef,
+      email: purchaseData.email,
+      name: purchaseData.name,
+      purchases: purchaseData.purchases,
+      hasPlan: (planName) => {
+        return purchaseData.purchases.some(
+          (p) => p.planName.toLowerCase() === planName.toLowerCase() && p.status === "active"
+        );
+      },
+      activePurchase,
+      hasPaidPurchase: activePaidPurchases.length > 0,
+      activePaidPurchase
+    };
+  }, [loading, purchaseData, internalCustomerRef]);
+  const contextValue = useMemo(
+    () => ({
+      purchase,
+      refetchPurchase,
+      createPayment,
+      processPayment,
+      customerRef: purchaseData.customerRef || internalCustomerRef,
+      updateCustomerRef
+    }),
+    [
+      purchase,
+      refetchPurchase,
+      createPayment,
+      processPayment,
+      purchaseData.customerRef,
+      internalCustomerRef,
+      updateCustomerRef
+    ]
+  );
+  return /* @__PURE__ */ jsx(SolvaPayContext.Provider, { value: contextValue, children });
+};
+
+// src/PaymentForm.tsx
+import { useEffect as useEffect2, useCallback as useCallback3, useRef as useRef3, useMemo as useMemo2, useState as useState4 } from "react";
+import { Elements } from "@stripe/react-stripe-js";
+
+// src/hooks/useCheckout.ts
+import { useState as useState2, useCallback as useCallback2, useRef as useRef2 } from "react";
+import { loadStripe } from "@stripe/stripe-js";
+
+// src/hooks/useSolvaPay.ts
+import { useContext } from "react";
+function useSolvaPay() {
+  const context = useContext(SolvaPayContext);
+  if (!context) {
+    throw new Error(
+      "useSolvaPay must be used within a SolvaPayProvider. Wrap your component tree with <SolvaPayProvider> to use this hook."
+    );
+  }
+  return context;
+}
+
+// src/hooks/useCheckout.ts
+var stripePromiseCache = /* @__PURE__ */ new Map();
+function getStripeCacheKey(publishableKey, accountId) {
+  return accountId ? `${publishableKey}:${accountId}` : publishableKey;
+}
+function useCheckout(options) {
+  const { planRef, productRef } = options;
+  const { createPayment, customerRef, updateCustomerRef } = useSolvaPay();
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(
+    !planRef || typeof planRef !== "string" ? new Error("useCheckout: planRef parameter is required and must be a string") : null
+  );
+  const [stripePromise, setStripePromise] = useState2(null);
+  const [clientSecret, setClientSecret] = useState2(null);
+  const isStartingRef = useRef2(false);
+  const startCheckout = useCallback2(async () => {
+    if (isStartingRef.current || loading) {
+      return;
+    }
+    if (!planRef || typeof planRef !== "string") {
+      setError(new Error("useCheckout: planRef parameter is required and must be a string"));
+      return;
+    }
+    isStartingRef.current = true;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await createPayment({ planRef, productRef });
+      if (!result || typeof result !== "object") {
+        throw new Error("Invalid payment intent response from server");
+      }
+      if (!result.clientSecret || typeof result.clientSecret !== "string") {
+        throw new Error("Invalid client secret in payment intent response");
+      }
+      if (!result.publishableKey || typeof result.publishableKey !== "string") {
+        throw new Error("Invalid publishable key in payment intent response");
+      }
+      if (result.customerRef && result.customerRef !== customerRef && updateCustomerRef) {
+        updateCustomerRef(result.customerRef);
+      }
       const stripeOptions = result.accountId ? { stripeAccount: result.accountId } : {};
-      const stripe = await loadStripe(result.publishableKey, stripeOptions);
+      const cacheKey = getStripeCacheKey(result.publishableKey, result.accountId);
+      let stripe = stripePromiseCache.get(cacheKey);
       if (!stripe) {
-        throw new Error("Failed to initialize Stripe. Please check your configuration.");
+        stripe = loadStripe(result.publishableKey, stripeOptions);
+        stripePromiseCache.set(cacheKey, stripe);
       }
       setStripePromise(stripe);
       setClientSecret(result.clientSecret);
-      if (onPaymentReady) {
-        onPaymentReady(stripe, result.clientSecret);
-      }
-    } catch (error2) {
-      console.error("Failed to create payment:", error2);
-      let errorMessage = "Payment creation failed";
-      if (error2 instanceof Error) {
-        if (error2.message.includes("publishable key")) {
-          errorMessage = "Server configuration error: Missing Stripe publishable key";
-        } else if (error2.message.includes("client secret")) {
-          errorMessage = "Server error: Payment intent creation failed";
-        } else if (error2.message.includes("Failed to initialize Stripe")) {
-          errorMessage = "Stripe initialization failed. Please check your configuration.";
-        } else {
-          errorMessage = error2.message;
-        }
-      }
-      setError(errorMessage);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to start checkout");
+      setError(error2);
     } finally {
       setLoading(false);
+      isStartingRef.current = false;
     }
+  }, [planRef, productRef, createPayment, updateCustomerRef, loading]);
+  const reset = useCallback2(() => {
+    isStartingRef.current = false;
+    setLoading(false);
+    setError(null);
+    setStripePromise(null);
+    setClientSecret(null);
+  }, []);
+  return {
+    loading,
+    error,
+    stripePromise,
+    clientSecret,
+    startCheckout,
+    reset
   };
-  useEffect(() => {
-    if (amount && !stripePromise && !loading && !error) {
-      createPayment(amount);
-    }
-  }, [amount]);
-  if (error) {
-    return /* @__PURE__ */ jsxs("div", { style: {
-      padding: "1rem",
-      backgroundColor: "#fed7d7",
-      color: "#742a2a",
-      borderRadius: "0.375rem",
-      marginBottom: "1rem"
-    }, children: [
-      /* @__PURE__ */ jsx("strong", { children: "Payment Setup Error:" }),
-      " ",
-      error,
-      /* @__PURE__ */ jsx(
-        "button",
-        {
-          onClick: () => createPayment(amount),
-          style: {
-            marginLeft: "1rem",
-            padding: "0.5rem 1rem",
-            backgroundColor: "#742a2a",
-            color: "white",
-            border: "none",
-            borderRadius: "0.25rem",
-            cursor: "pointer"
-          },
-          children: "Retry"
-        }
-      )
-    ] });
-  }
-  if (loading) {
-    return /* @__PURE__ */ jsx("div", { style: {
-      padding: "1rem",
-      textAlign: "center",
-      color: "#4a5568"
-    }, children: "Setting up payment..." });
-  }
-  if (!stripePromise || !clientSecret) {
-    return /* @__PURE__ */ jsx("div", { style: {
-      padding: "1rem",
-      textAlign: "center",
-      color: "#4a5568"
-    }, children: /* @__PURE__ */ jsx(
-      "button",
-      {
-        onClick: () => createPayment(amount),
-        style: {
-          padding: "0.75rem 1.5rem",
-          backgroundColor: "#3182ce",
-          color: "white",
-          border: "none",
-          borderRadius: "0.375rem",
-          cursor: "pointer",
-          fontSize: "1rem"
-        },
-        children: "Initialize Payment"
-      }
-    ) });
-  }
-  return /* @__PURE__ */ jsx(Elements, { stripe: stripePromise, options: { clientSecret }, children });
+}
+
+// src/hooks/usePurchase.ts
+function usePurchase() {
+  const { purchase, refetchPurchase } = useSolvaPay();
+  return {
+    ...purchase,
+    refetch: refetchPurchase
+  };
+}
+
+// src/components/Spinner.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var Spinner = ({
+  className = "",
+  size = "md"
+}) => {
+  const sizeClasses = {
+    sm: "h-4 w-4",
+    md: "h-5 w-5",
+    lg: "h-6 w-6"
+  };
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      className: `animate-spin ${sizeClasses[size]} ${className}`,
+      xmlns: "http://www.w3.org/2000/svg",
+      fill: "none",
+      viewBox: "0 0 24 24",
+      role: "status",
+      "aria-busy": "true",
+      children: [
+        /* @__PURE__ */ jsx2("circle", { className: "opacity-25", cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "4" }),
+        /* @__PURE__ */ jsx2(
+          "path",
+          {
+            className: "opacity-75",
+            fill: "currentColor",
+            d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+          }
+        )
+      ]
+    }
+  );
 };
 
-// src/PaymentForm.tsx
-import { useState as useState2 } from "react";
-import { useStripe, useElements, PaymentElement } from "@stripe/react-stripe-js";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var PaymentForm = ({
+// src/components/StripePaymentFormWrapper.tsx
+import { useState as useState3 } from "react";
+import { useStripe, useElements, CardElement } from "@stripe/react-stripe-js";
+
+// src/hooks/useCustomer.ts
+function useCustomer() {
+  const { purchase, customerRef } = useSolvaPay();
+  return {
+    customerRef: purchase.customerRef || customerRef,
+    email: purchase.email,
+    name: purchase.name,
+    loading: purchase.loading
+  };
+}
+
+// src/components/StripePaymentFormWrapper.tsx
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var StripePaymentFormWrapper = ({
   onSuccess,
   onError,
-  returnUrl,
+  returnUrl: _returnUrl,
   submitButtonText = "Pay Now",
-  className
+  buttonClassName,
+  clientSecret
 }) => {
   const stripe = useStripe();
   const elements = useElements();
-  const [isProcessing, setIsProcessing] = useState2(false);
-  const [message, setMessage] = useState2(null);
+  const customer = useCustomer();
+  const [isProcessing, setIsProcessing] = useState3(false);
+  const [message, setMessage] = useState3(null);
+  const [cardComplete, setCardComplete] = useState3(false);
   const handleSubmit = async (event) => {
     event.preventDefault();
     if (!stripe || !elements) {
+      const errorMessage = "Stripe is not available. Please refresh the page.";
+      setMessage(errorMessage);
+      if (onError) {
+        onError(new Error(errorMessage));
+      }
+      return;
+    }
+    if (!clientSecret) {
+      const errorMessage = "Payment intent not available. Please refresh the page.";
+      setMessage(errorMessage);
+      if (onError) {
+        onError(new Error(errorMessage));
+      }
       return;
     }
     setIsProcessing(true);
     setMessage(null);
     try {
-      const { error, paymentIntent } = await stripe.confirmPayment({
-        elements,
-        confirmParams: {
-          return_url: returnUrl || `${window.location.origin}/checkout/complete`
-        },
-        redirect: "if_required"
-        // Only redirect if required by payment method
+      const cardElement = elements.getElement(CardElement);
+      if (!cardElement) {
+        const errorMessage = "Card element not found";
+        setMessage(errorMessage);
+        setIsProcessing(false);
+        if (onError) {
+          onError(new Error(errorMessage));
+        }
+        return;
+      }
+      const { error, paymentIntent } = await stripe.confirmCardPayment(clientSecret, {
+        payment_method: {
+          card: cardElement,
+          billing_details: {
+            email: customer.email,
+            name: customer.name
+          }
+        }
       });
       if (error) {
         const errorMessage = error.message || "An unexpected error occurred.";
         setMessage(errorMessage);
+        setIsProcessing(false);
         if (onError) {
           onError(new Error(errorMessage));
         }
       } else if (paymentIntent && paymentIntent.status === "succeeded") {
-        setMessage("Payment successful!");
+        setMessage(null);
         if (onSuccess) {
-          onSuccess(paymentIntent);
+          try {
+            await onSuccess(paymentIntent);
+            setMessage("Payment successful!");
+          } catch (err) {
+            const error2 = err instanceof Error ? err : new Error("Payment processing failed");
+            setMessage("Payment processing failed. Please try again or contact support.");
+            setIsProcessing(false);
+            if (onError) {
+              onError(error2);
+            }
+            return;
+          }
+        } else {
+          setMessage("Payment successful!");
         }
-      } else {
-        setMessage(`Payment status: ${paymentIntent?.status || "processing"}`);
+      } else if (paymentIntent && paymentIntent.status === "requires_action") {
+        setMessage("Payment requires additional authentication. Please complete the verification.");
+        setIsProcessing(false);
+      } else if (paymentIntent) {
+        setMessage(`Payment status: ${paymentIntent.status || "processing"}`);
+        setIsProcessing(false);
       }
     } catch (err) {
       const error = err instanceof Error ? err : new Error("Unknown error occurred");
@@ -200,45 +674,574 @@ var PaymentForm = ({
       setIsProcessing(false);
     }
   };
-  return /* @__PURE__ */ jsxs2("form", { onSubmit: handleSubmit, className, children: [
-    /* @__PURE__ */ jsx2(PaymentElement, {}),
-    message && /* @__PURE__ */ jsx2(
+  const isSuccess = message?.includes("successful") ?? false;
+  const isReady = !!(stripe && elements);
+  const cardElementOptions = {
+    style: {
+      base: {
+        fontSize: "16px",
+        color: "#424770",
+        "::placeholder": {
+          color: "#aab7c4"
+        }
+      },
+      invalid: {
+        color: "#9e2146"
+      }
+    },
+    hidePostalCode: true
+  };
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    isReady ? /* @__PURE__ */ jsx3(
+      CardElement,
+      {
+        options: cardElementOptions,
+        onChange: (e) => {
+          if (e.error) {
+            setMessage(e.error.message);
+            setCardComplete(false);
+          } else {
+            setMessage(null);
+            setCardComplete(e.complete);
+          }
+        }
+      }
+    ) : /* @__PURE__ */ jsx3(
       "div",
       {
         style: {
-          marginTop: "1rem",
-          padding: "0.75rem",
+          padding: "12px",
+          border: "1px solid #cbd5e1",
           borderRadius: "0.375rem",
-          backgroundColor: message.includes("successful") ? "#d1fae5" : "#fee2e2",
-          color: message.includes("successful") ? "#065f46" : "#7f1d1d"
+          backgroundColor: "white",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          minHeight: "40px"
         },
-        children: message
+        children: /* @__PURE__ */ jsx3(Spinner, { size: "sm" })
       }
     ),
-    /* @__PURE__ */ jsx2(
+    message && !isSuccess && /* @__PURE__ */ jsx3("div", { role: "alert", "aria-live": "assertive", "aria-atomic": "true", children: message }),
+    /* @__PURE__ */ jsx3(
       "button",
       {
         type: "submit",
-        disabled: !stripe || isProcessing,
-        style: {
-          marginTop: "1.5rem",
-          width: "100%",
-          padding: "0.75rem 1.5rem",
-          backgroundColor: isProcessing || !stripe ? "#9ca3af" : "#3b82f6",
-          color: "white",
-          border: "none",
-          borderRadius: "0.375rem",
-          fontSize: "1rem",
-          fontWeight: "500",
-          cursor: isProcessing || !stripe ? "not-allowed" : "pointer",
-          transition: "background-color 0.2s"
-        },
-        children: isProcessing ? "Processing..." : submitButtonText
+        disabled: !isReady || !cardComplete || isProcessing || !clientSecret,
+        className: buttonClassName,
+        "aria-busy": isProcessing,
+        "aria-disabled": !isReady || !cardComplete || isProcessing || !clientSecret,
+        onClick: handleSubmit,
+        children: isProcessing ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+          /* @__PURE__ */ jsx3(Spinner, { size: "sm" }),
+          /* @__PURE__ */ jsx3("span", { children: "Processing..." })
+        ] }) : submitButtonText
       }
     )
   ] });
 };
+
+// src/PaymentForm.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var PaymentForm = ({
+  planRef,
+  productRef,
+  onSuccess,
+  onError,
+  returnUrl,
+  submitButtonText = "Pay Now",
+  className,
+  buttonClassName
+}) => {
+  const validPlanRef = planRef && typeof planRef === "string" ? planRef : "";
+  const {
+    loading: checkoutLoading,
+    error: checkoutError,
+    clientSecret,
+    startCheckout,
+    stripePromise
+  } = useCheckout({ planRef: validPlanRef, productRef });
+  const { refetch } = usePurchase();
+  const { processPayment } = useSolvaPay();
+  const hasInitializedRef = useRef3(false);
+  useEffect2(() => {
+    if (!hasInitializedRef.current && validPlanRef && !checkoutLoading && !checkoutError && !clientSecret) {
+      hasInitializedRef.current = true;
+      startCheckout().catch(() => {
+        hasInitializedRef.current = false;
+      });
+    }
+    if (validPlanRef && clientSecret) {
+      hasInitializedRef.current = true;
+    }
+  }, [validPlanRef, checkoutLoading, checkoutError, clientSecret, startCheckout]);
+  const handleSuccess = useCallback3(
+    async (paymentIntent) => {
+      let processingTimeout = false;
+      let processingResult = null;
+      const paymentIntentAny = paymentIntent;
+      if (processPayment && productRef) {
+        try {
+          const result = await processPayment({
+            paymentIntentId: paymentIntentAny.id,
+            productRef,
+            planRef
+          });
+          processingResult = result;
+          const isTimeout = result?.status === "timeout";
+          processingTimeout = isTimeout;
+          if (isTimeout) {
+            for (let attempt = 1; attempt <= 5; attempt++) {
+              const delay = attempt * 1e3;
+              await new Promise((resolve) => setTimeout(resolve, delay));
+              await refetch();
+            }
+            if (onSuccess) {
+              await onSuccess({
+                ...paymentIntentAny,
+                _processingTimeout: processingTimeout,
+                _processingResult: processingResult
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              });
+            }
+            throw new Error("Payment processing timed out");
+          } else {
+            await refetch();
+          }
+        } catch (error) {
+          console.error("[PaymentForm] Failed to process payment:", error);
+          if (onSuccess) {
+            try {
+              await onSuccess({
+                ...paymentIntentAny,
+                _processingError: error
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              });
+            } catch {
+            }
+          }
+          throw error;
+        }
+      } else {
+        await refetch();
+      }
+      if (onSuccess && !processingTimeout) {
+        await onSuccess({
+          ...paymentIntentAny,
+          _processingTimeout: processingTimeout,
+          _processingResult: processingResult
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
+      }
+    },
+    [processPayment, productRef, planRef, refetch, onSuccess]
+  );
+  const handleError = useCallback3(
+    (err) => {
+      if (onError) {
+        onError(err);
+      }
+    },
+    [onError]
+  );
+  const finalReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
+  const isValidPlanRef = planRef && typeof planRef === "string";
+  const hasError = !!checkoutError;
+  const hasStripeData = !!(stripePromise && clientSecret);
+  const elementsOptions = useMemo2(() => {
+    if (!clientSecret) return void 0;
+    return { clientSecret };
+  }, [clientSecret]);
+  const [hasMountedElements, setHasMountedElements] = useState4(false);
+  useEffect2(() => {
+    if (hasStripeData) {
+      setHasMountedElements(true);
+    }
+  }, [hasStripeData]);
+  const shouldRenderElements = hasStripeData || hasMountedElements && stripePromise && clientSecret;
+  return /* @__PURE__ */ jsx4("div", { className, children: !isValidPlanRef ? /* @__PURE__ */ jsx4("div", { children: "PaymentForm: planRef is required and must be a string" }) : hasError ? /* @__PURE__ */ jsxs3("div", { children: [
+    /* @__PURE__ */ jsx4("div", { children: "Payment initialization failed" }),
+    /* @__PURE__ */ jsx4("div", { children: checkoutError?.message || "Unknown error" })
+  ] }) : shouldRenderElements && elementsOptions ? (
+    // Once we have Stripe data, always render Elements to maintain hook consistency
+    // This prevents hook count mismatches when transitioning between states
+    /* @__PURE__ */ jsx4(
+      Elements,
+      {
+        stripe: stripePromise,
+        options: elementsOptions,
+        children: /* @__PURE__ */ jsx4(
+          StripePaymentFormWrapper,
+          {
+            onSuccess: handleSuccess,
+            onError: handleError,
+            returnUrl: finalReturnUrl,
+            submitButtonText,
+            buttonClassName,
+            clientSecret
+          }
+        )
+      },
+      clientSecret
+    )
+  ) : (
+    // Loading state before Stripe data is available
+    /* @__PURE__ */ jsxs3("div", { children: [
+      /* @__PURE__ */ jsx4(
+        "div",
+        {
+          style: {
+            minHeight: "40px",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center"
+          },
+          children: /* @__PURE__ */ jsx4(Spinner, { size: "md" })
+        }
+      ),
+      /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "submit",
+          disabled: true,
+          className: buttonClassName,
+          "aria-busy": "false",
+          "aria-disabled": "true",
+          children: submitButtonText
+        }
+      )
+    ] })
+  ) });
+};
+
+// src/components/PlanBadge.tsx
+import { useState as useState5, useEffect as useEffect3, useRef as useRef4 } from "react";
+import { Fragment as Fragment2, jsx as jsx5 } from "react/jsx-runtime";
+var PlanBadge = ({
+  children,
+  as: Component = "div",
+  className
+}) => {
+  const { purchases, loading, hasPaidPurchase, activePurchase } = usePurchase();
+  const [displayPlan, setDisplayPlan] = useState5(null);
+  const [hasLoadedOnce, setHasLoadedOnce] = useState5(false);
+  const lastPlanRef = useRef4(null);
+  const lastLoadingRef = useRef4(true);
+  const previousPurchasesRef = useRef4(purchases);
+  const currentPlanName = activePurchase?.planName || null;
+  const effectivePlanName = currentPlanName;
+  useEffect3(() => {
+    if (!loading && !hasLoadedOnce) {
+      setHasLoadedOnce(true);
+    }
+    lastLoadingRef.current = loading;
+  }, [loading, hasLoadedOnce]);
+  useEffect3(() => {
+    const previousPurchases = previousPurchasesRef.current;
+    if (previousPurchases !== purchases) {
+      if (loading) {
+        setHasLoadedOnce(false);
+      }
+      setDisplayPlan(null);
+      lastPlanRef.current = null;
+      previousPurchasesRef.current = purchases;
+    }
+  }, [purchases, loading]);
+  useEffect3(() => {
+    const currentPlan = effectivePlanName;
+    const previousPlan = lastPlanRef.current;
+    if (currentPlan !== previousPlan) {
+      if (currentPlan !== null) {
+        lastPlanRef.current = currentPlan;
+        setDisplayPlan(currentPlan);
+      } else {
+        lastPlanRef.current = null;
+        setDisplayPlan(null);
+      }
+    } else if (currentPlan !== null && displayPlan === null) {
+      setDisplayPlan(currentPlan);
+    }
+  }, [effectivePlanName, displayPlan]);
+  const shouldShow = effectivePlanName !== null && hasLoadedOnce;
+  const planToDisplay = displayPlan ?? effectivePlanName;
+  if (children) {
+    return /* @__PURE__ */ jsx5(Fragment2, { children: children({ purchases, loading, displayPlan: planToDisplay, shouldShow }) });
+  }
+  if (!shouldShow) {
+    return null;
+  }
+  const computedClassName = typeof className === "function" ? className({ purchases }) : className;
+  return /* @__PURE__ */ jsx5(
+    Component,
+    {
+      className: computedClassName,
+      "data-loading": loading,
+      "data-has-purchase": !!activePurchase,
+      "data-has-paid-purchase": hasPaidPurchase,
+      role: "status",
+      "aria-live": "polite",
+      "aria-busy": loading,
+      "aria-label": `Current plan: ${planToDisplay}`,
+      children: planToDisplay
+    }
+  );
+};
+
+// src/components/PurchaseGate.tsx
+import { Fragment as Fragment3, jsx as jsx6 } from "react/jsx-runtime";
+var PurchaseGate = ({ requirePlan, requireProduct, children }) => {
+  const { purchases, loading, hasPlan } = usePurchase();
+  const hasAccess = requirePlan ? hasPlan(requirePlan) : requireProduct ? purchases.some((p) => p.status === "active" && (p.productName === requireProduct || p.productReference === requireProduct)) : purchases.some((p) => p.status === "active");
+  return /* @__PURE__ */ jsx6(Fragment3, { children: children({
+    hasAccess,
+    purchases,
+    loading
+  }) });
+};
+
+// src/components/PlanSelector.tsx
+import { useCallback as useCallback5, useMemo as useMemo4 } from "react";
+
+// src/hooks/usePlans.ts
+import { useState as useState6, useEffect as useEffect4, useCallback as useCallback4, useMemo as useMemo3, useRef as useRef5 } from "react";
+var plansCache = /* @__PURE__ */ new Map();
+var CACHE_DURATION2 = 5 * 60 * 1e3;
+function usePlans(options) {
+  const { fetcher, productRef, filter, sortBy, autoSelectFirstPaid = false } = options;
+  const [plans, setPlans] = useState6([]);
+  const [loading, setLoading] = useState6(true);
+  const [error, setError] = useState6(null);
+  const [selectedPlanIndex, setSelectedPlanIndex] = useState6(0);
+  const fetcherRef = useRef5(fetcher);
+  const filterRef = useRef5(filter);
+  const sortByRef = useRef5(sortBy);
+  const autoSelectFirstPaidRef = useRef5(autoSelectFirstPaid);
+  useEffect4(() => {
+    fetcherRef.current = fetcher;
+  }, [fetcher]);
+  useEffect4(() => {
+    filterRef.current = filter;
+  }, [filter]);
+  useEffect4(() => {
+    sortByRef.current = sortBy;
+  }, [sortBy]);
+  useEffect4(() => {
+    autoSelectFirstPaidRef.current = autoSelectFirstPaid;
+  }, [autoSelectFirstPaid]);
+  const fetchPlans = useCallback4(
+    async (force = false) => {
+      if (!productRef) {
+        setError(new Error("Product reference not configured"));
+        setLoading(false);
+        return;
+      }
+      const cached = plansCache.get(productRef);
+      const now = Date.now();
+      if (!force && cached && now - cached.timestamp < CACHE_DURATION2) {
+        const cachedPlans = cached.plans;
+        let processedPlans = filterRef.current ? cachedPlans.filter(filterRef.current) : cachedPlans;
+        if (sortByRef.current) {
+          processedPlans = [...processedPlans].sort(sortByRef.current);
+        }
+        setPlans(processedPlans);
+        setLoading(false);
+        setError(null);
+        if (autoSelectFirstPaidRef.current && processedPlans.length > 0) {
+          const firstPaidIndex = processedPlans.findIndex((plan) => plan.price && plan.price > 0);
+          setSelectedPlanIndex(firstPaidIndex >= 0 ? firstPaidIndex : 0);
+        }
+        return;
+      }
+      if (cached?.promise) {
+        try {
+          setLoading(true);
+          const fetchedPlans = await cached.promise;
+          let processedPlans = filterRef.current ? fetchedPlans.filter(filterRef.current) : fetchedPlans;
+          if (sortByRef.current) {
+            processedPlans = [...processedPlans].sort(sortByRef.current);
+          }
+          setPlans(processedPlans);
+          setError(null);
+          if (autoSelectFirstPaidRef.current && processedPlans.length > 0) {
+            const firstPaidIndex = processedPlans.findIndex((plan) => plan.price && plan.price > 0);
+            setSelectedPlanIndex(firstPaidIndex >= 0 ? firstPaidIndex : 0);
+          }
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error("Failed to load plans"));
+        } finally {
+          setLoading(false);
+        }
+        return;
+      }
+      try {
+        setLoading(true);
+        setError(null);
+        const fetchPromise = fetcherRef.current(productRef);
+        plansCache.set(productRef, {
+          plans: [],
+          timestamp: now,
+          promise: fetchPromise
+        });
+        const fetchedPlans = await fetchPromise;
+        plansCache.set(productRef, {
+          plans: fetchedPlans,
+          timestamp: now,
+          promise: null
+        });
+        let processedPlans = filterRef.current ? fetchedPlans.filter(filterRef.current) : fetchedPlans;
+        if (sortByRef.current) {
+          processedPlans = [...processedPlans].sort(sortByRef.current);
+        }
+        setPlans(processedPlans);
+        if (autoSelectFirstPaidRef.current && processedPlans.length > 0) {
+          const firstPaidIndex = processedPlans.findIndex((plan) => plan.price && plan.price > 0);
+          setSelectedPlanIndex(firstPaidIndex >= 0 ? firstPaidIndex : 0);
+        }
+      } catch (err) {
+        plansCache.delete(productRef);
+        setError(err instanceof Error ? err : new Error("Failed to load plans"));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [productRef]
+  );
+  useEffect4(() => {
+    fetchPlans();
+  }, [fetchPlans]);
+  const selectedPlan = useMemo3(() => {
+    return plans[selectedPlanIndex] || null;
+  }, [plans, selectedPlanIndex]);
+  const selectPlan = useCallback4(
+    (planRef) => {
+      const index = plans.findIndex((p) => p.reference === planRef);
+      if (index >= 0) {
+        setSelectedPlanIndex(index);
+      }
+    },
+    [plans]
+  );
+  return {
+    plans,
+    loading,
+    error,
+    selectedPlanIndex,
+    selectedPlan,
+    setSelectedPlanIndex,
+    selectPlan,
+    refetch: () => fetchPlans(true)
+    // Force refetch
+  };
+}
+
+// src/components/PlanSelector.tsx
+import { Fragment as Fragment4, jsx as jsx7 } from "react/jsx-runtime";
+var PlanSelector = ({
+  productRef,
+  fetcher,
+  filter,
+  sortBy,
+  autoSelectFirstPaid,
+  children
+}) => {
+  const { purchases } = usePurchase();
+  const plansHook = usePlans({
+    productRef,
+    fetcher,
+    filter,
+    sortBy,
+    autoSelectFirstPaid
+  });
+  const { plans } = plansHook;
+  const isPaidPlan = useCallback5(
+    (planName) => {
+      const plan = plans.find((p) => p.name === planName);
+      return plan ? (plan.price ?? 0) > 0 && !plan.isFreeTier : true;
+    },
+    [plans]
+  );
+  const activePurchase = useMemo4(() => {
+    const activePurchases = purchases.filter((p) => p.status === "active");
+    return activePurchases.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
+  }, [purchases]);
+  const isCurrentPlan = useCallback5(
+    (planName) => {
+      return activePurchase?.planName === planName;
+    },
+    [activePurchase]
+  );
+  return /* @__PURE__ */ jsx7(Fragment4, { children: children({
+    ...plansHook,
+    purchases,
+    isPaidPlan,
+    isCurrentPlan
+  }) });
+};
+
+// src/hooks/usePurchaseStatus.ts
+import { useMemo as useMemo5, useCallback as useCallback6 } from "react";
+function usePurchaseStatus() {
+  const { purchases } = usePurchase();
+  const isPaidPurchase2 = useCallback6((p) => {
+    return (p.amount ?? 0) > 0;
+  }, []);
+  const purchaseData = useMemo5(() => {
+    const cancelledPaidPurchases = purchases.filter((p) => {
+      return p.status === "active" && p.cancelledAt && isPaidPurchase2(p);
+    });
+    const cancelledPurchase = cancelledPaidPurchases.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
+    const shouldShowCancelledNotice = !!cancelledPurchase;
+    return {
+      cancelledPurchase,
+      shouldShowCancelledNotice
+    };
+  }, [purchases, isPaidPurchase2]);
+  const formatDate = useCallback6((dateString) => {
+    if (!dateString) return null;
+    return new Date(dateString).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+  }, []);
+  const getDaysUntilExpiration = useCallback6((endDate) => {
+    if (!endDate) return null;
+    const now = /* @__PURE__ */ new Date();
+    const expiration = new Date(endDate);
+    const diffTime = expiration.getTime() - now.getTime();
+    const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+    return diffDays > 0 ? diffDays : 0;
+  }, []);
+  return {
+    cancelledPurchase: purchaseData.cancelledPurchase,
+    shouldShowCancelledNotice: purchaseData.shouldShowCancelledNotice,
+    formatDate,
+    getDaysUntilExpiration
+  };
+}
 export {
   PaymentForm,
-  SolvaPayProvider
+  PlanBadge,
+  PlanSelector,
+  PurchaseGate,
+  SolvaPayProvider,
+  Spinner,
+  StripePaymentFormWrapper,
+  defaultAuthAdapter,
+  filterPurchases,
+  getActivePurchases,
+  getCancelledPurchasesWithEndDate,
+  getMostRecentPurchase,
+  getPrimaryPurchase,
+  isPaidPurchase,
+  useCheckout,
+  useCustomer,
+  usePlans,
+  usePurchase,
+  usePurchaseStatus,
+  useSolvaPay
 };