@solvapay/react 1.0.0-preview.17 → 1.0.0-preview.19

package/dist/index.js

@@ -15,8 +15,7 @@ function getActiveSubscriptions(subscriptions) {
 function getCancelledSubscriptionsWithEndDate(subscriptions) {
   const now = /* @__PURE__ */ new Date();
   return subscriptions.filter((sub) => {
-    const subAny = sub;
-    return sub.status === "active" && subAny.cancelledAt && subAny.endDate && new Date(subAny.endDate) > now;
+    return sub.status === "active" && sub.cancelledAt && sub.endDate && new Date(sub.endDate) > now;
   });
 }
 function getMostRecentSubscription(subscriptions) {
@@ -114,7 +113,9 @@ var SolvaPayProvider = ({
   const createPaymentRef = useRef(null);
   const processPaymentRef = useRef(null);
   const configRef = useRef(config);
-  const buildDefaultCheckSubscriptionRef = useRef(null);
+  const buildDefaultCheckSubscriptionRef = useRef(
+    null
+  );
   useEffect(() => {
     configRef.current = config;
   }, [config]);
@@ -162,77 +163,83 @@ var SolvaPayProvider = ({
   useEffect(() => {
     buildDefaultCheckSubscriptionRef.current = buildDefaultCheckSubscription;
   }, [buildDefaultCheckSubscription]);
-  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.agentRef) {
-      body.agentRef = params.agentRef;
-    }
-    const res = await fetchFn(route, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    });
-    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 checkSubscription = useCallback(async () => {
+  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.agentRef) {
+        body.agentRef = params.agentRef;
+      }
+      const res = await fetchFn(route, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      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 _checkSubscription = useCallback(async () => {
     if (checkSubscriptionRef.current) {
       return checkSubscriptionRef.current();
     }
@@ -240,19 +247,25 @@ var SolvaPayProvider = ({
       return buildDefaultCheckSubscriptionRef.current();
     }
     return buildDefaultCheckSubscription();
-  }, []);
-  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]);
+  }, [buildDefaultCheckSubscription]);
+  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;
@@ -281,58 +294,61 @@ var SolvaPayProvider = ({
     const interval = setInterval(detectAuth, 5e3);
     return () => clearInterval(interval);
   }, [userId]);
-  const fetchSubscription = useCallback(async (force = false) => {
-    if (!isAuthenticated && !internalCustomerRef) {
-      setSubscriptionData({ subscriptions: [] });
-      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 = checkSubscriptionRef.current || buildDefaultCheckSubscriptionRef.current;
-      if (!checkFn) {
-        throw new Error("checkSubscription 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);
+  const fetchSubscription = useCallback(
+    async (force = false) => {
+      if (!isAuthenticated && !internalCustomerRef) {
+        setSubscriptionData({ subscriptions: [] });
+        setLoading(false);
+        inFlightRef.current = null;
+        lastFetchedRef.current = null;
+        return;
       }
-      if (inFlightRef.current === cacheKey) {
-        const filteredData = {
-          ...data,
-          subscriptions: filterSubscriptions(data.subscriptions || [])
-        };
-        setSubscriptionData(filteredData);
-        lastFetchedRef.current = cacheKey;
+      const cacheKey = internalCustomerRef || userId || "anonymous";
+      if (!force && lastFetchedRef.current === cacheKey && inFlightRef.current !== cacheKey) {
+        return;
       }
-    } catch (error) {
-      console.error("[SolvaPayProvider] Failed to fetch subscription:", error);
       if (inFlightRef.current === cacheKey) {
-        setSubscriptionData({
-          subscriptions: []
-        });
-        lastFetchedRef.current = cacheKey;
+        return;
       }
-    } finally {
-      if (inFlightRef.current === cacheKey) {
-        setLoading(false);
-        inFlightRef.current = null;
+      inFlightRef.current = cacheKey;
+      setLoading(true);
+      try {
+        const checkFn = checkSubscriptionRef.current || buildDefaultCheckSubscriptionRef.current;
+        if (!checkFn) {
+          throw new Error("checkSubscription 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,
+            subscriptions: filterSubscriptions(data.subscriptions || [])
+          };
+          setSubscriptionData(filteredData);
+          lastFetchedRef.current = cacheKey;
+        }
+      } catch (error) {
+        console.error("[SolvaPayProvider] Failed to fetch subscription:", error);
+        if (inFlightRef.current === cacheKey) {
+          setSubscriptionData({
+            subscriptions: []
+          });
+          lastFetchedRef.current = cacheKey;
+        }
+      } finally {
+        if (inFlightRef.current === cacheKey) {
+          setLoading(false);
+          inFlightRef.current = null;
+        }
       }
-    }
-  }, [isAuthenticated, internalCustomerRef, userId]);
+    },
+    [isAuthenticated, internalCustomerRef, userId]
+  );
   const fetchSubscriptionRef = useRef(fetchSubscription);
   useEffect(() => {
     fetchSubscriptionRef.current = fetchSubscription;
@@ -353,17 +369,22 @@ var SolvaPayProvider = ({
       setLoading(false);
     }
   }, [isAuthenticated, internalCustomerRef, userId]);
-  const updateCustomerRef = useCallback((newCustomerRef) => {
-    setInternalCustomerRef(newCustomerRef);
-    setCachedCustomerRef(newCustomerRef, userId);
-    fetchSubscription(true);
-  }, [fetchSubscription, userId]);
+  const updateCustomerRef = useCallback(
+    (newCustomerRef) => {
+      setInternalCustomerRef(newCustomerRef);
+      setCachedCustomerRef(newCustomerRef, userId);
+      fetchSubscription(true);
+    },
+    [fetchSubscription, userId]
+  );
   const subscription = useMemo(() => {
     const activeSubscription = getPrimarySubscription(subscriptionData.subscriptions);
     const activePaidSubscriptions = subscriptionData.subscriptions.filter(
       (sub) => sub.status === "active" && isPaidSubscription(sub)
     );
-    const activePaidSubscription = activePaidSubscriptions.sort((a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime())[0] || null;
+    const activePaidSubscription = activePaidSubscriptions.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
     return {
       loading,
       customerRef: subscriptionData.customerRef || internalCustomerRef,
@@ -380,14 +401,25 @@ var SolvaPayProvider = ({
       activePaidSubscription
     };
   }, [loading, subscriptionData, internalCustomerRef]);
-  const contextValue = useMemo(() => ({
-    subscription,
-    refetchSubscription,
-    createPayment,
-    processPayment,
-    customerRef: subscriptionData.customerRef || internalCustomerRef,
-    updateCustomerRef
-  }), [subscription, refetchSubscription, createPayment, processPayment, subscriptionData.customerRef, internalCustomerRef, updateCustomerRef]);
+  const contextValue = useMemo(
+    () => ({
+      subscription,
+      refetchSubscription,
+      createPayment,
+      processPayment,
+      customerRef: subscriptionData.customerRef || internalCustomerRef,
+      updateCustomerRef
+    }),
+    [
+      subscription,
+      refetchSubscription,
+      createPayment,
+      processPayment,
+      subscriptionData.customerRef,
+      internalCustomerRef,
+      updateCustomerRef
+    ]
+  );
   return /* @__PURE__ */ jsx(SolvaPayContext.Provider, { value: contextValue, children });
 };
 
@@ -493,17 +525,6 @@ function useSubscription() {
   };
 }
 
-// src/hooks/useCustomer.ts
-function useCustomer() {
-  const { subscription, customerRef } = useSolvaPay();
-  return {
-    customerRef: subscription.customerRef || customerRef,
-    email: subscription.email,
-    name: subscription.name,
-    loading: subscription.loading
-  };
-}
-
 // src/components/Spinner.tsx
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
 var Spinner = ({
@@ -525,17 +546,7 @@ var Spinner = ({
       role: "status",
       "aria-busy": "true",
       children: [
-        /* @__PURE__ */ jsx2(
-          "circle",
-          {
-            className: "opacity-25",
-            cx: "12",
-            cy: "12",
-            r: "10",
-            stroke: "currentColor",
-            strokeWidth: "4"
-          }
-        ),
+        /* @__PURE__ */ jsx2("circle", { className: "opacity-25", cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "4" }),
         /* @__PURE__ */ jsx2(
           "path",
           {
@@ -552,11 +563,24 @@ var Spinner = ({
 // 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 { subscription, customerRef } = useSolvaPay();
+  return {
+    customerRef: subscription.customerRef || customerRef,
+    email: subscription.email,
+    name: subscription.name,
+    loading: subscription.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",
   buttonClassName,
   clientSecret
@@ -681,16 +705,23 @@ var StripePaymentFormWrapper = ({
           }
         }
       }
-    ) : /* @__PURE__ */ jsx3("div", { style: { padding: "12px", border: "1px solid #cbd5e1", borderRadius: "0.375rem", backgroundColor: "white", display: "flex", alignItems: "center", justifyContent: "center", minHeight: "40px" }, children: /* @__PURE__ */ jsx3(Spinner, { size: "sm" }) }),
-    message && !isSuccess && /* @__PURE__ */ jsx3(
+    ) : /* @__PURE__ */ jsx3(
       "div",
       {
-        role: "alert",
-        "aria-live": "assertive",
-        "aria-atomic": "true",
-        children: message
+        style: {
+          padding: "12px",
+          border: "1px solid #cbd5e1",
+          borderRadius: "0.375rem",
+          backgroundColor: "white",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          minHeight: "40px"
+        },
+        children: /* @__PURE__ */ jsx3(Spinner, { size: "sm" })
       }
     ),
+    message && !isSuccess && /* @__PURE__ */ jsx3("div", { role: "alert", "aria-live": "assertive", "aria-atomic": "true", children: message }),
     /* @__PURE__ */ jsx3(
       "button",
       {
@@ -722,106 +753,118 @@ var PaymentForm = ({
   buttonClassName
 }) => {
   const validPlanRef = planRef && typeof planRef === "string" ? planRef : "";
-  const checkout = useCheckout(validPlanRef, agentRef);
+  const {
+    loading: checkoutLoading,
+    error: checkoutError,
+    clientSecret,
+    startCheckout,
+    stripePromise
+  } = useCheckout(validPlanRef, agentRef);
   const { refetch } = useSubscription();
-  const { processPayment, customerRef } = useSolvaPay();
-  const customer = useCustomer();
+  const { processPayment } = useSolvaPay();
   const hasInitializedRef = useRef3(false);
   useEffect2(() => {
-    if (!hasInitializedRef.current && validPlanRef && !checkout.loading && !checkout.error && !checkout.clientSecret) {
+    if (!hasInitializedRef.current && validPlanRef && !checkoutLoading && !checkoutError && !clientSecret) {
       hasInitializedRef.current = true;
-      checkout.startCheckout().catch(() => {
+      startCheckout().catch(() => {
         hasInitializedRef.current = false;
       });
     }
-    if (validPlanRef && checkout.clientSecret) {
+    if (validPlanRef && clientSecret) {
       hasInitializedRef.current = true;
     }
-  }, [validPlanRef, checkout.loading, checkout.error, checkout.clientSecret, checkout.startCheckout]);
-  const handleSuccess = useCallback3(async (paymentIntent) => {
-    let processingTimeout = false;
-    let processingResult = null;
-    if (processPayment && agentRef) {
-      try {
-        const result = await processPayment({
-          paymentIntentId: paymentIntent.id,
-          agentRef,
-          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));
+  }, [validPlanRef, checkoutLoading, checkoutError, clientSecret, startCheckout]);
+  const handleSuccess = useCallback3(
+    async (paymentIntent) => {
+      let processingTimeout = false;
+      let processingResult = null;
+      const paymentIntentAny = paymentIntent;
+      if (processPayment && agentRef) {
+        try {
+          const result = await processPayment({
+            paymentIntentId: paymentIntentAny.id,
+            agentRef,
+            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
+              });
+            }
+            throw new Error("Payment processing timed out");
+          } else {
             await refetch();
           }
+        } catch (error) {
+          console.error("[PaymentForm] Failed to process payment:", error);
           if (onSuccess) {
-            await onSuccess({
-              ...paymentIntent,
-              _processingTimeout: processingTimeout,
-              _processingResult: processingResult
-            });
-          }
-          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({
-              ...paymentIntent,
-              _processingError: error
-            });
-          } catch (callbackError) {
+            try {
+              await onSuccess({
+                ...paymentIntentAny,
+                _processingError: error
+              });
+            } catch {
+            }
           }
+          throw error;
         }
-        throw error;
+      } else {
+        await refetch();
       }
-    } else {
-      await refetch();
-    }
-    if (onSuccess && !processingTimeout) {
-      await onSuccess({
-        ...paymentIntent,
-        _processingTimeout: processingTimeout,
-        _processingResult: processingResult
-      });
-    }
-  }, [processPayment, agentRef, planRef, refetch, onSuccess]);
-  const handleError = useCallback3((err) => {
-    if (onError) {
-      onError(err);
-    }
-  }, [onError]);
+      if (onSuccess && !processingTimeout) {
+        await onSuccess({
+          ...paymentIntentAny,
+          _processingTimeout: processingTimeout,
+          _processingResult: processingResult
+        });
+      }
+    },
+    [processPayment, agentRef, 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 = !!checkout.error;
-  const hasStripeData = !!(checkout.stripePromise && checkout.clientSecret);
+  const hasError = !!checkoutError;
+  const hasStripeData = !!(stripePromise && clientSecret);
   const elementsOptions = useMemo2(() => {
-    if (!checkout.clientSecret) return void 0;
-    return { clientSecret: checkout.clientSecret };
-  }, [checkout.clientSecret]);
+    if (!clientSecret) return void 0;
+    return { clientSecret };
+  }, [clientSecret]);
   const [hasMountedElements, setHasMountedElements] = useState4(false);
   useEffect2(() => {
     if (hasStripeData) {
       setHasMountedElements(true);
     }
   }, [hasStripeData]);
-  const shouldRenderElements = hasStripeData || hasMountedElements && checkout.stripePromise && checkout.clientSecret;
+  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: checkout.error?.message || "Unknown error" })
-  ] }) : shouldRenderElements && checkout.stripePromise && elementsOptions ? (
+    /* @__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: checkout.stripePromise,
+        stripe: stripePromise,
         options: elementsOptions,
         children: /* @__PURE__ */ jsx4(
           StripePaymentFormWrapper,
@@ -831,16 +874,27 @@ var PaymentForm = ({
             returnUrl: finalReturnUrl,
             submitButtonText,
             buttonClassName,
-            clientSecret: checkout.clientSecret
+            clientSecret
           }
         )
       },
-      checkout.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(
+        "div",
+        {
+          style: {
+            minHeight: "40px",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center"
+          },
+          children: /* @__PURE__ */ jsx4(Spinner, { size: "md" })
+        }
+      ),
       /* @__PURE__ */ jsx4(
         "button",
         {
@@ -931,10 +985,7 @@ var PlanBadge = ({
 
 // src/components/SubscriptionGate.tsx
 import { Fragment as Fragment3, jsx as jsx6 } from "react/jsx-runtime";
-var SubscriptionGate = ({
-  requirePlan,
-  children
-}) => {
+var SubscriptionGate = ({ requirePlan, children }) => {
   const { subscriptions, loading, hasPlan } = useSubscription();
   const hasAccess = requirePlan ? hasPlan(requirePlan) : subscriptions.some((sub) => sub.status === "active");
   return /* @__PURE__ */ jsx6(Fragment3, { children: children({
@@ -973,99 +1024,99 @@ function usePlans(options) {
   useEffect4(() => {
     autoSelectFirstPaidRef.current = autoSelectFirstPaid;
   }, [autoSelectFirstPaid]);
-  const fetchPlans = useCallback4(async (force = false) => {
-    if (!agentRef) {
-      setError(new Error("Agent reference not configured"));
-      setLoading(false);
-      return;
-    }
-    const cached = plansCache.get(agentRef);
-    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);
+  const fetchPlans = useCallback4(
+    async (force = false) => {
+      if (!agentRef) {
+        setError(new Error("Agent reference not configured"));
+        setLoading(false);
+        return;
       }
-      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);
+      const cached = plansCache.get(agentRef);
+      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;
       }
-      return;
-    }
-    if (cached?.promise) {
       try {
         setLoading(true);
-        const fetchedPlans = await cached.promise;
+        setError(null);
+        const fetchPromise = fetcherRef.current(agentRef);
+        plansCache.set(agentRef, {
+          plans: [],
+          timestamp: now,
+          promise: fetchPromise
+        });
+        const fetchedPlans = await fetchPromise;
+        plansCache.set(agentRef, {
+          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);
-        setError(null);
         if (autoSelectFirstPaidRef.current && processedPlans.length > 0) {
-          const firstPaidIndex = processedPlans.findIndex(
-            (plan) => plan.price && plan.price > 0
-          );
+          const firstPaidIndex = processedPlans.findIndex((plan) => plan.price && plan.price > 0);
           setSelectedPlanIndex(firstPaidIndex >= 0 ? firstPaidIndex : 0);
         }
       } catch (err) {
+        plansCache.delete(agentRef);
         setError(err instanceof Error ? err : new Error("Failed to load plans"));
       } finally {
         setLoading(false);
       }
-      return;
-    }
-    try {
-      setLoading(true);
-      setError(null);
-      const fetchPromise = fetcherRef.current(agentRef);
-      plansCache.set(agentRef, {
-        plans: [],
-        timestamp: now,
-        promise: fetchPromise
-      });
-      const fetchedPlans = await fetchPromise;
-      plansCache.set(agentRef, {
-        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(agentRef);
-      setError(err instanceof Error ? err : new Error("Failed to load plans"));
-    } finally {
-      setLoading(false);
-    }
-  }, [agentRef]);
+    },
+    [agentRef]
+  );
   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]);
+  const selectPlan = useCallback4(
+    (planRef) => {
+      const index = plans.findIndex((p) => p.reference === planRef);
+      if (index >= 0) {
+        setSelectedPlanIndex(index);
+      }
+    },
+    [plans]
+  );
   return {
     plans,
     loading,
@@ -1098,19 +1149,25 @@ var PlanSelector = ({
     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 isPaidPlan = useCallback5(
+    (planName) => {
+      const plan = plans.find((p) => p.name === planName);
+      return plan ? (plan.price ?? 0) > 0 && !plan.isFreeTier : true;
+    },
+    [plans]
+  );
   const activeSubscription = useMemo4(() => {
     const activeSubs = subscriptions.filter((sub) => sub.status === "active");
     return activeSubs.sort(
       (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
     )[0] || null;
   }, [subscriptions]);
-  const isCurrentPlan = useCallback5((planName) => {
-    return activeSubscription?.planName === planName;
-  }, [activeSubscription]);
+  const isCurrentPlan = useCallback5(
+    (planName) => {
+      return activeSubscription?.planName === planName;
+    },
+    [activeSubscription]
+  );
   return /* @__PURE__ */ jsx7(Fragment4, { children: children({
     ...plansHook,
     subscriptions,
@@ -1128,10 +1185,11 @@ function useSubscriptionStatus() {
   }, []);
   const subscriptionData = useMemo5(() => {
     const cancelledPaidSubscriptions = subscriptions.filter((sub) => {
-      const subAny = sub;
-      return sub.status === "active" && subAny.cancelledAt && isPaidSubscription2(sub);
+      return sub.status === "active" && sub.cancelledAt && isPaidSubscription2(sub);
     });
-    const cancelledSubscription = cancelledPaidSubscriptions.sort((a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime())[0] || null;
+    const cancelledSubscription = cancelledPaidSubscriptions.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
     const shouldShowCancelledNotice = !!cancelledSubscription;
     return {
       cancelledSubscription,