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

package/dist/index.js

@@ -5,34 +5,34 @@ import {
 // src/SolvaPayProvider.tsx
 import { createContext, useState, useEffect, useCallback, useMemo, useRef } from "react";
 
-// src/utils/subscriptions.ts
-function filterSubscriptions(subscriptions) {
-  return subscriptions.filter((sub) => sub.status === "active");
+// src/utils/purchases.ts
+function filterPurchases(purchases) {
+  return purchases.filter((purchase) => purchase.status === "active");
 }
-function getActiveSubscriptions(subscriptions) {
-  return subscriptions.filter((sub) => sub.status === "active");
+function getActivePurchases(purchases) {
+  return purchases.filter((purchase) => purchase.status === "active");
 }
-function getCancelledSubscriptionsWithEndDate(subscriptions) {
+function getCancelledPurchasesWithEndDate(purchases) {
   const now = /* @__PURE__ */ new Date();
-  return subscriptions.filter((sub) => {
-    return sub.status === "active" && sub.cancelledAt && sub.endDate && new Date(sub.endDate) > now;
+  return purchases.filter((purchase) => {
+    return purchase.status === "active" && purchase.cancelledAt && purchase.endDate && new Date(purchase.endDate) > now;
   });
 }
-function getMostRecentSubscription(subscriptions) {
-  if (subscriptions.length === 0) return null;
-  return subscriptions.reduce((latest, current) => {
+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 getPrimarySubscription(subscriptions) {
-  const filtered = filterSubscriptions(subscriptions);
+function getPrimaryPurchase(purchases) {
+  const filtered = filterPurchases(purchases);
   if (filtered.length > 0) {
-    return getMostRecentSubscription(filtered);
+    return getMostRecentPurchase(filtered);
   }
   return null;
 }
-function isPaidSubscription(sub) {
-  return (sub.amount ?? 0) > 0;
+function isPaidPurchase(purchase) {
+  return (purchase.amount ?? 0) > 0;
 }
 
 // src/SolvaPayProvider.tsx
@@ -96,12 +96,12 @@ function getAuthAdapter(config) {
 var SolvaPayProvider = ({
   config,
   createPayment: customCreatePayment,
-  checkSubscription: customCheckSubscription,
+  checkPurchase: customCheckPurchase,
   processPayment: customProcessPayment,
   children
 }) => {
-  const [subscriptionData, setSubscriptionData] = useState({
-    subscriptions: []
+  const [purchaseData, setPurchaseData] = useState({
+    purchases: []
   });
   const [loading, setLoading] = useState(false);
   const [internalCustomerRef, setInternalCustomerRef] = useState(void 0);
@@ -109,31 +109,31 @@ var SolvaPayProvider = ({
   const [isAuthenticated, setIsAuthenticated] = useState(false);
   const inFlightRef = useRef(null);
   const lastFetchedRef = useRef(null);
-  const checkSubscriptionRef = useRef(null);
+  const checkPurchaseRef = useRef(null);
   const createPaymentRef = useRef(null);
   const processPaymentRef = useRef(null);
   const configRef = useRef(config);
-  const buildDefaultCheckSubscriptionRef = useRef(
+  const buildDefaultCheckPurchaseRef = useRef(
     null
   );
   useEffect(() => {
     configRef.current = config;
   }, [config]);
   useEffect(() => {
-    checkSubscriptionRef.current = customCheckSubscription || null;
-  }, [customCheckSubscription]);
+    checkPurchaseRef.current = customCheckPurchase || null;
+  }, [customCheckPurchase]);
   useEffect(() => {
     createPaymentRef.current = customCreatePayment || null;
   }, [customCreatePayment]);
   useEffect(() => {
     processPaymentRef.current = customProcessPayment || null;
   }, [customProcessPayment]);
-  const buildDefaultCheckSubscription = useCallback(async () => {
+  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?.checkSubscription || "/api/check-subscription";
+    const route = currentConfig?.api?.checkPurchase || "/api/check-purchase";
     const fetchFn = currentConfig?.fetch || fetch;
     const cachedRef = getCachedCustomerRef(detectedUserId);
     const headers = {
@@ -154,15 +154,15 @@ var SolvaPayProvider = ({
       headers
     });
     if (!res.ok) {
-      const error = new Error(`Failed to check subscription: ${res.statusText}`);
-      currentConfig?.onError?.(error, "checkSubscription");
+      const error = new Error(`Failed to check purchase: ${res.statusText}`);
+      currentConfig?.onError?.(error, "checkPurchase");
       throw error;
     }
     return res.json();
   }, []);
   useEffect(() => {
-    buildDefaultCheckSubscriptionRef.current = buildDefaultCheckSubscription;
-  }, [buildDefaultCheckSubscription]);
+    buildDefaultCheckPurchaseRef.current = buildDefaultCheckPurchase;
+  }, [buildDefaultCheckPurchase]);
   const buildDefaultCreatePayment = useCallback(
     async (params) => {
       const currentConfig = configRef.current;
@@ -186,8 +186,8 @@ var SolvaPayProvider = ({
         Object.assign(headers, customHeaders);
       }
       const body = { planRef: params.planRef };
-      if (params.agentRef) {
-        body.agentRef = params.agentRef;
+      if (params.productRef) {
+        body.productRef = params.productRef;
       }
       const res = await fetchFn(route, {
         method: "POST",
@@ -239,15 +239,15 @@ var SolvaPayProvider = ({
     },
     []
   );
-  const _checkSubscription = useCallback(async () => {
-    if (checkSubscriptionRef.current) {
-      return checkSubscriptionRef.current();
+  const _checkPurchase = useCallback(async () => {
+    if (checkPurchaseRef.current) {
+      return checkPurchaseRef.current();
     }
-    if (buildDefaultCheckSubscriptionRef.current) {
-      return buildDefaultCheckSubscriptionRef.current();
+    if (buildDefaultCheckPurchaseRef.current) {
+      return buildDefaultCheckPurchaseRef.current();
     }
-    return buildDefaultCheckSubscription();
-  }, [buildDefaultCheckSubscription]);
+    return buildDefaultCheckPurchase();
+  }, [buildDefaultCheckPurchase]);
   const createPayment = useCallback(
     async (params) => {
       if (createPaymentRef.current) {
@@ -294,10 +294,10 @@ var SolvaPayProvider = ({
     const interval = setInterval(detectAuth, 5e3);
     return () => clearInterval(interval);
   }, [userId]);
-  const fetchSubscription = useCallback(
+  const fetchPurchase = useCallback(
     async (force = false) => {
       if (!isAuthenticated && !internalCustomerRef) {
-        setSubscriptionData({ subscriptions: [] });
+        setPurchaseData({ purchases: [] });
         setLoading(false);
         inFlightRef.current = null;
         lastFetchedRef.current = null;
@@ -313,9 +313,9 @@ var SolvaPayProvider = ({
       inFlightRef.current = cacheKey;
       setLoading(true);
       try {
-        const checkFn = checkSubscriptionRef.current || buildDefaultCheckSubscriptionRef.current;
+        const checkFn = checkPurchaseRef.current || buildDefaultCheckPurchaseRef.current;
         if (!checkFn) {
-          throw new Error("checkSubscription function not available");
+          throw new Error("checkPurchase function not available");
         }
         const data = await checkFn();
         if (data.customerRef) {
@@ -327,16 +327,16 @@ var SolvaPayProvider = ({
         if (inFlightRef.current === cacheKey) {
           const filteredData = {
             ...data,
-            subscriptions: filterSubscriptions(data.subscriptions || [])
+            purchases: filterPurchases(data.purchases || [])
           };
-          setSubscriptionData(filteredData);
+          setPurchaseData(filteredData);
           lastFetchedRef.current = cacheKey;
         }
       } catch (error) {
-        console.error("[SolvaPayProvider] Failed to fetch subscription:", error);
+        console.error("[SolvaPayProvider] Failed to fetch purchase:", error);
         if (inFlightRef.current === cacheKey) {
-          setSubscriptionData({
-            subscriptions: []
+          setPurchaseData({
+            purchases: []
           });
           lastFetchedRef.current = cacheKey;
         }
@@ -349,23 +349,23 @@ var SolvaPayProvider = ({
     },
     [isAuthenticated, internalCustomerRef, userId]
   );
-  const fetchSubscriptionRef = useRef(fetchSubscription);
+  const fetchPurchaseRef = useRef(fetchPurchase);
   useEffect(() => {
-    fetchSubscriptionRef.current = fetchSubscription;
-  }, [fetchSubscription]);
-  const refetchSubscription = useCallback(async () => {
+    fetchPurchaseRef.current = fetchPurchase;
+  }, [fetchPurchase]);
+  const refetchPurchase = useCallback(async () => {
     lastFetchedRef.current = null;
     inFlightRef.current = null;
-    setSubscriptionData({ subscriptions: [] });
-    await fetchSubscriptionRef.current(true);
+    setPurchaseData({ purchases: [] });
+    await fetchPurchaseRef.current(true);
   }, []);
   useEffect(() => {
     lastFetchedRef.current = null;
     inFlightRef.current = null;
     if (isAuthenticated || internalCustomerRef) {
-      fetchSubscription();
+      fetchPurchase();
     } else {
-      setSubscriptionData({ subscriptions: [] });
+      setPurchaseData({ purchases: [] });
       setLoading(false);
     }
   }, [isAuthenticated, internalCustomerRef, userId]);
@@ -373,49 +373,49 @@ var SolvaPayProvider = ({
     (newCustomerRef) => {
       setInternalCustomerRef(newCustomerRef);
       setCachedCustomerRef(newCustomerRef, userId);
-      fetchSubscription(true);
+      fetchPurchase(true);
     },
-    [fetchSubscription, userId]
+    [fetchPurchase, userId]
   );
-  const subscription = useMemo(() => {
-    const activeSubscription = getPrimarySubscription(subscriptionData.subscriptions);
-    const activePaidSubscriptions = subscriptionData.subscriptions.filter(
-      (sub) => sub.status === "active" && isPaidSubscription(sub)
+  const purchase = useMemo(() => {
+    const activePurchase = getPrimaryPurchase(purchaseData.purchases);
+    const activePaidPurchases = purchaseData.purchases.filter(
+      (p) => p.status === "active" && isPaidPurchase(p)
     );
-    const activePaidSubscription = activePaidSubscriptions.sort(
+    const activePaidPurchase = activePaidPurchases.sort(
       (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
     )[0] || null;
     return {
       loading,
-      customerRef: subscriptionData.customerRef || internalCustomerRef,
-      email: subscriptionData.email,
-      name: subscriptionData.name,
-      subscriptions: subscriptionData.subscriptions,
+      customerRef: purchaseData.customerRef || internalCustomerRef,
+      email: purchaseData.email,
+      name: purchaseData.name,
+      purchases: purchaseData.purchases,
       hasPlan: (planName) => {
-        return subscriptionData.subscriptions.some(
-          (sub) => sub.planName.toLowerCase() === planName.toLowerCase() && sub.status === "active"
+        return purchaseData.purchases.some(
+          (p) => p.planName.toLowerCase() === planName.toLowerCase() && p.status === "active"
         );
       },
-      activeSubscription,
-      hasPaidSubscription: activePaidSubscriptions.length > 0,
-      activePaidSubscription
+      activePurchase,
+      hasPaidPurchase: activePaidPurchases.length > 0,
+      activePaidPurchase
     };
-  }, [loading, subscriptionData, internalCustomerRef]);
+  }, [loading, purchaseData, internalCustomerRef]);
   const contextValue = useMemo(
     () => ({
-      subscription,
-      refetchSubscription,
+      purchase,
+      refetchPurchase,
       createPayment,
       processPayment,
-      customerRef: subscriptionData.customerRef || internalCustomerRef,
+      customerRef: purchaseData.customerRef || internalCustomerRef,
       updateCustomerRef
     }),
     [
-      subscription,
-      refetchSubscription,
+      purchase,
+      refetchPurchase,
       createPayment,
       processPayment,
-      subscriptionData.customerRef,
+      purchaseData.customerRef,
       internalCustomerRef,
       updateCustomerRef
     ]
@@ -448,7 +448,8 @@ var stripePromiseCache = /* @__PURE__ */ new Map();
 function getStripeCacheKey(publishableKey, accountId) {
   return accountId ? `${publishableKey}:${accountId}` : publishableKey;
 }
-function useCheckout(planRef, agentRef) {
+function useCheckout(options) {
+  const { planRef, productRef } = options;
   const { createPayment, customerRef, updateCustomerRef } = useSolvaPay();
   const [loading, setLoading] = useState2(false);
   const [error, setError] = useState2(
@@ -469,7 +470,7 @@ function useCheckout(planRef, agentRef) {
     setLoading(true);
     setError(null);
     try {
-      const result = await createPayment({ planRef, agentRef });
+      const result = await createPayment({ planRef, productRef });
       if (!result || typeof result !== "object") {
         throw new Error("Invalid payment intent response from server");
       }
@@ -498,7 +499,7 @@ function useCheckout(planRef, agentRef) {
       setLoading(false);
       isStartingRef.current = false;
     }
-  }, [planRef, agentRef, createPayment, updateCustomerRef, loading]);
+  }, [planRef, productRef, createPayment, updateCustomerRef, loading]);
   const reset = useCallback2(() => {
     isStartingRef.current = false;
     setLoading(false);
@@ -516,12 +517,12 @@ function useCheckout(planRef, agentRef) {
   };
 }
 
-// src/hooks/useSubscription.ts
-function useSubscription() {
-  const { subscription, refetchSubscription } = useSolvaPay();
+// src/hooks/usePurchase.ts
+function usePurchase() {
+  const { purchase, refetchPurchase } = useSolvaPay();
   return {
-    ...subscription,
-    refetch: refetchSubscription
+    ...purchase,
+    refetch: refetchPurchase
   };
 }
 
@@ -566,12 +567,12 @@ import { useStripe, useElements, CardElement } from "@stripe/react-stripe-js";
 
 // src/hooks/useCustomer.ts
 function useCustomer() {
-  const { subscription, customerRef } = useSolvaPay();
+  const { purchase, customerRef } = useSolvaPay();
   return {
-    customerRef: subscription.customerRef || customerRef,
-    email: subscription.email,
-    name: subscription.name,
-    loading: subscription.loading
+    customerRef: purchase.customerRef || customerRef,
+    email: purchase.email,
+    name: purchase.name,
+    loading: purchase.loading
   };
 }
 
@@ -744,7 +745,7 @@ var StripePaymentFormWrapper = ({
 import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 var PaymentForm = ({
   planRef,
-  agentRef,
+  productRef,
   onSuccess,
   onError,
   returnUrl,
@@ -759,8 +760,8 @@ var PaymentForm = ({
     clientSecret,
     startCheckout,
     stripePromise
-  } = useCheckout(validPlanRef, agentRef);
-  const { refetch } = useSubscription();
+  } = useCheckout({ planRef: validPlanRef, productRef });
+  const { refetch } = usePurchase();
   const { processPayment } = useSolvaPay();
   const hasInitializedRef = useRef3(false);
   useEffect2(() => {
@@ -779,11 +780,11 @@ var PaymentForm = ({
       let processingTimeout = false;
       let processingResult = null;
       const paymentIntentAny = paymentIntent;
-      if (processPayment && agentRef) {
+      if (processPayment && productRef) {
         try {
           const result = await processPayment({
             paymentIntentId: paymentIntentAny.id,
-            agentRef,
+            productRef,
             planRef
           });
           processingResult = result;
@@ -800,6 +801,7 @@ var PaymentForm = ({
                 ...paymentIntentAny,
                 _processingTimeout: processingTimeout,
                 _processingResult: processingResult
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
               });
             }
             throw new Error("Payment processing timed out");
@@ -813,6 +815,7 @@ var PaymentForm = ({
               await onSuccess({
                 ...paymentIntentAny,
                 _processingError: error
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
               });
             } catch {
             }
@@ -827,10 +830,11 @@ var PaymentForm = ({
           ...paymentIntentAny,
           _processingTimeout: processingTimeout,
           _processingResult: processingResult
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
         });
       }
     },
-    [processPayment, agentRef, planRef, refetch, onSuccess]
+    [processPayment, productRef, planRef, refetch, onSuccess]
   );
   const handleError = useCallback3(
     (err) => {
@@ -918,13 +922,13 @@ var PlanBadge = ({
   as: Component = "div",
   className
 }) => {
-  const { subscriptions, loading, hasPaidSubscription, activeSubscription } = useSubscription();
+  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 previousSubscriptionsRef = useRef4(subscriptions);
-  const currentPlanName = activeSubscription?.planName || null;
+  const previousPurchasesRef = useRef4(purchases);
+  const currentPlanName = activePurchase?.planName || null;
   const effectivePlanName = currentPlanName;
   useEffect3(() => {
     if (!loading && !hasLoadedOnce) {
@@ -933,16 +937,16 @@ var PlanBadge = ({
     lastLoadingRef.current = loading;
   }, [loading, hasLoadedOnce]);
   useEffect3(() => {
-    const previousSubs = previousSubscriptionsRef.current;
-    if (previousSubs !== subscriptions) {
+    const previousPurchases = previousPurchasesRef.current;
+    if (previousPurchases !== purchases) {
       if (loading) {
         setHasLoadedOnce(false);
       }
       setDisplayPlan(null);
       lastPlanRef.current = null;
-      previousSubscriptionsRef.current = subscriptions;
+      previousPurchasesRef.current = purchases;
     }
-  }, [subscriptions, loading]);
+  }, [purchases, loading]);
   useEffect3(() => {
     const currentPlan = effectivePlanName;
     const previousPlan = lastPlanRef.current;
@@ -961,19 +965,19 @@ var PlanBadge = ({
   const shouldShow = effectivePlanName !== null && hasLoadedOnce;
   const planToDisplay = displayPlan ?? effectivePlanName;
   if (children) {
-    return /* @__PURE__ */ jsx5(Fragment2, { children: children({ subscriptions, loading, displayPlan: planToDisplay, shouldShow }) });
+    return /* @__PURE__ */ jsx5(Fragment2, { children: children({ purchases, loading, displayPlan: planToDisplay, shouldShow }) });
   }
   if (!shouldShow) {
     return null;
   }
-  const computedClassName = typeof className === "function" ? className({ subscriptions }) : className;
+  const computedClassName = typeof className === "function" ? className({ purchases }) : className;
   return /* @__PURE__ */ jsx5(
     Component,
     {
       className: computedClassName,
       "data-loading": loading,
-      "data-has-subscription": !!activeSubscription,
-      "data-has-paid-subscription": hasPaidSubscription,
+      "data-has-purchase": !!activePurchase,
+      "data-has-paid-purchase": hasPaidPurchase,
       role: "status",
       "aria-live": "polite",
       "aria-busy": loading,
@@ -983,14 +987,14 @@ var PlanBadge = ({
   );
 };
 
-// src/components/SubscriptionGate.tsx
+// src/components/PurchaseGate.tsx
 import { Fragment as Fragment3, jsx as jsx6 } from "react/jsx-runtime";
-var SubscriptionGate = ({ requirePlan, children }) => {
-  const { subscriptions, loading, hasPlan } = useSubscription();
-  const hasAccess = requirePlan ? hasPlan(requirePlan) : subscriptions.some((sub) => sub.status === "active");
+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,
-    subscriptions,
+    purchases,
     loading
   }) });
 };
@@ -1003,7 +1007,7 @@ import { useState as useState6, useEffect as useEffect4, useCallback as useCallb
 var plansCache = /* @__PURE__ */ new Map();
 var CACHE_DURATION2 = 5 * 60 * 1e3;
 function usePlans(options) {
-  const { fetcher, agentRef, filter, sortBy, autoSelectFirstPaid = false } = options;
+  const { fetcher, productRef, filter, sortBy, autoSelectFirstPaid = false } = options;
   const [plans, setPlans] = useState6([]);
   const [loading, setLoading] = useState6(true);
   const [error, setError] = useState6(null);
@@ -1026,12 +1030,12 @@ function usePlans(options) {
   }, [autoSelectFirstPaid]);
   const fetchPlans = useCallback4(
     async (force = false) => {
-      if (!agentRef) {
-        setError(new Error("Agent reference not configured"));
+      if (!productRef) {
+        setError(new Error("Product reference not configured"));
         setLoading(false);
         return;
       }
-      const cached = plansCache.get(agentRef);
+      const cached = plansCache.get(productRef);
       const now = Date.now();
       if (!force && cached && now - cached.timestamp < CACHE_DURATION2) {
         const cachedPlans = cached.plans;
@@ -1072,14 +1076,14 @@ function usePlans(options) {
       try {
         setLoading(true);
         setError(null);
-        const fetchPromise = fetcherRef.current(agentRef);
-        plansCache.set(agentRef, {
+        const fetchPromise = fetcherRef.current(productRef);
+        plansCache.set(productRef, {
           plans: [],
           timestamp: now,
           promise: fetchPromise
         });
         const fetchedPlans = await fetchPromise;
-        plansCache.set(agentRef, {
+        plansCache.set(productRef, {
           plans: fetchedPlans,
           timestamp: now,
           promise: null
@@ -1094,13 +1098,13 @@ function usePlans(options) {
           setSelectedPlanIndex(firstPaidIndex >= 0 ? firstPaidIndex : 0);
         }
       } catch (err) {
-        plansCache.delete(agentRef);
+        plansCache.delete(productRef);
         setError(err instanceof Error ? err : new Error("Failed to load plans"));
       } finally {
         setLoading(false);
       }
     },
-    [agentRef]
+    [productRef]
   );
   useEffect4(() => {
     fetchPlans();
@@ -1133,16 +1137,16 @@ function usePlans(options) {
 // src/components/PlanSelector.tsx
 import { Fragment as Fragment4, jsx as jsx7 } from "react/jsx-runtime";
 var PlanSelector = ({
-  agentRef,
+  productRef,
   fetcher,
   filter,
   sortBy,
   autoSelectFirstPaid,
   children
 }) => {
-  const { subscriptions } = useSubscription();
+  const { purchases } = usePurchase();
   const plansHook = usePlans({
-    agentRef,
+    productRef,
     fetcher,
     filter,
     sortBy,
@@ -1156,46 +1160,46 @@ var PlanSelector = ({
     },
     [plans]
   );
-  const activeSubscription = useMemo4(() => {
-    const activeSubs = subscriptions.filter((sub) => sub.status === "active");
-    return activeSubs.sort(
+  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;
-  }, [subscriptions]);
+  }, [purchases]);
   const isCurrentPlan = useCallback5(
     (planName) => {
-      return activeSubscription?.planName === planName;
+      return activePurchase?.planName === planName;
     },
-    [activeSubscription]
+    [activePurchase]
   );
   return /* @__PURE__ */ jsx7(Fragment4, { children: children({
     ...plansHook,
-    subscriptions,
+    purchases,
     isPaidPlan,
     isCurrentPlan
   }) });
 };
 
-// src/hooks/useSubscriptionStatus.ts
+// src/hooks/usePurchaseStatus.ts
 import { useMemo as useMemo5, useCallback as useCallback6 } from "react";
-function useSubscriptionStatus() {
-  const { subscriptions } = useSubscription();
-  const isPaidSubscription2 = useCallback6((sub) => {
-    return (sub.amount ?? 0) > 0;
+function usePurchaseStatus() {
+  const { purchases } = usePurchase();
+  const isPaidPurchase2 = useCallback6((p) => {
+    return (p.amount ?? 0) > 0;
   }, []);
-  const subscriptionData = useMemo5(() => {
-    const cancelledPaidSubscriptions = subscriptions.filter((sub) => {
-      return sub.status === "active" && sub.cancelledAt && isPaidSubscription2(sub);
+  const purchaseData = useMemo5(() => {
+    const cancelledPaidPurchases = purchases.filter((p) => {
+      return p.status === "active" && p.cancelledAt && isPaidPurchase2(p);
     });
-    const cancelledSubscription = cancelledPaidSubscriptions.sort(
+    const cancelledPurchase = cancelledPaidPurchases.sort(
       (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
     )[0] || null;
-    const shouldShowCancelledNotice = !!cancelledSubscription;
+    const shouldShowCancelledNotice = !!cancelledPurchase;
     return {
-      cancelledSubscription,
+      cancelledPurchase,
       shouldShowCancelledNotice
     };
-  }, [subscriptions, isPaidSubscription2]);
+  }, [purchases, isPaidPurchase2]);
   const formatDate = useCallback6((dateString) => {
     if (!dateString) return null;
     return new Date(dateString).toLocaleDateString("en-US", {
@@ -1213,8 +1217,8 @@ function useSubscriptionStatus() {
     return diffDays > 0 ? diffDays : 0;
   }, []);
   return {
-    cancelledSubscription: subscriptionData.cancelledSubscription,
-    shouldShowCancelledNotice: subscriptionData.shouldShowCancelledNotice,
+    cancelledPurchase: purchaseData.cancelledPurchase,
+    shouldShowCancelledNotice: purchaseData.shouldShowCancelledNotice,
     formatDate,
     getDaysUntilExpiration
   };
@@ -1223,21 +1227,21 @@ export {
   PaymentForm,
   PlanBadge,
   PlanSelector,
+  PurchaseGate,
   SolvaPayProvider,
   Spinner,
   StripePaymentFormWrapper,
-  SubscriptionGate,
   defaultAuthAdapter,
-  filterSubscriptions,
-  getActiveSubscriptions,
-  getCancelledSubscriptionsWithEndDate,
-  getMostRecentSubscription,
-  getPrimarySubscription,
-  isPaidSubscription,
+  filterPurchases,
+  getActivePurchases,
+  getCancelledPurchasesWithEndDate,
+  getMostRecentPurchase,
+  getPrimaryPurchase,
+  isPaidPurchase,
   useCheckout,
   useCustomer,
   usePlans,
-  useSolvaPay,
-  useSubscription,
-  useSubscriptionStatus
+  usePurchase,
+  usePurchaseStatus,
+  useSolvaPay
 };