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

package/dist/index.cjs

@@ -23,57 +23,57 @@ __export(index_exports, {
   PaymentForm: () => PaymentForm,
   PlanBadge: () => PlanBadge,
   PlanSelector: () => PlanSelector,
+  PurchaseGate: () => PurchaseGate,
   SolvaPayProvider: () => SolvaPayProvider,
   Spinner: () => Spinner,
   StripePaymentFormWrapper: () => StripePaymentFormWrapper,
-  SubscriptionGate: () => SubscriptionGate,
   defaultAuthAdapter: () => defaultAuthAdapter,
-  filterSubscriptions: () => filterSubscriptions,
-  getActiveSubscriptions: () => getActiveSubscriptions,
-  getCancelledSubscriptionsWithEndDate: () => getCancelledSubscriptionsWithEndDate,
-  getMostRecentSubscription: () => getMostRecentSubscription,
-  getPrimarySubscription: () => getPrimarySubscription,
-  isPaidSubscription: () => isPaidSubscription,
+  filterPurchases: () => filterPurchases,
+  getActivePurchases: () => getActivePurchases,
+  getCancelledPurchasesWithEndDate: () => getCancelledPurchasesWithEndDate,
+  getMostRecentPurchase: () => getMostRecentPurchase,
+  getPrimaryPurchase: () => getPrimaryPurchase,
+  isPaidPurchase: () => isPaidPurchase,
   useCheckout: () => useCheckout,
   useCustomer: () => useCustomer,
   usePlans: () => usePlans,
-  useSolvaPay: () => useSolvaPay,
-  useSubscription: () => useSubscription,
-  useSubscriptionStatus: () => useSubscriptionStatus
+  usePurchase: () => usePurchase,
+  usePurchaseStatus: () => usePurchaseStatus,
+  useSolvaPay: () => useSolvaPay
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/SolvaPayProvider.tsx
 var import_react = require("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/adapters/auth.ts
@@ -159,12 +159,12 @@ function getAuthAdapter(config) {
 var SolvaPayProvider = ({
   config,
   createPayment: customCreatePayment,
-  checkSubscription: customCheckSubscription,
+  checkPurchase: customCheckPurchase,
   processPayment: customProcessPayment,
   children
 }) => {
-  const [subscriptionData, setSubscriptionData] = (0, import_react.useState)({
-    subscriptions: []
+  const [purchaseData, setPurchaseData] = (0, import_react.useState)({
+    purchases: []
   });
   const [loading, setLoading] = (0, import_react.useState)(false);
   const [internalCustomerRef, setInternalCustomerRef] = (0, import_react.useState)(void 0);
@@ -172,31 +172,31 @@ var SolvaPayProvider = ({
   const [isAuthenticated, setIsAuthenticated] = (0, import_react.useState)(false);
   const inFlightRef = (0, import_react.useRef)(null);
   const lastFetchedRef = (0, import_react.useRef)(null);
-  const checkSubscriptionRef = (0, import_react.useRef)(null);
+  const checkPurchaseRef = (0, import_react.useRef)(null);
   const createPaymentRef = (0, import_react.useRef)(null);
   const processPaymentRef = (0, import_react.useRef)(null);
   const configRef = (0, import_react.useRef)(config);
-  const buildDefaultCheckSubscriptionRef = (0, import_react.useRef)(
+  const buildDefaultCheckPurchaseRef = (0, import_react.useRef)(
     null
   );
   (0, import_react.useEffect)(() => {
     configRef.current = config;
   }, [config]);
   (0, import_react.useEffect)(() => {
-    checkSubscriptionRef.current = customCheckSubscription || null;
-  }, [customCheckSubscription]);
+    checkPurchaseRef.current = customCheckPurchase || null;
+  }, [customCheckPurchase]);
   (0, import_react.useEffect)(() => {
     createPaymentRef.current = customCreatePayment || null;
   }, [customCreatePayment]);
   (0, import_react.useEffect)(() => {
     processPaymentRef.current = customProcessPayment || null;
   }, [customProcessPayment]);
-  const buildDefaultCheckSubscription = (0, import_react.useCallback)(async () => {
+  const buildDefaultCheckPurchase = (0, import_react.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 = {
@@ -217,15 +217,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();
   }, []);
   (0, import_react.useEffect)(() => {
-    buildDefaultCheckSubscriptionRef.current = buildDefaultCheckSubscription;
-  }, [buildDefaultCheckSubscription]);
+    buildDefaultCheckPurchaseRef.current = buildDefaultCheckPurchase;
+  }, [buildDefaultCheckPurchase]);
   const buildDefaultCreatePayment = (0, import_react.useCallback)(
     async (params) => {
       const currentConfig = configRef.current;
@@ -249,8 +249,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",
@@ -302,15 +302,15 @@ var SolvaPayProvider = ({
     },
     []
   );
-  const _checkSubscription = (0, import_react.useCallback)(async () => {
-    if (checkSubscriptionRef.current) {
-      return checkSubscriptionRef.current();
+  const _checkPurchase = (0, import_react.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 = (0, import_react.useCallback)(
     async (params) => {
       if (createPaymentRef.current) {
@@ -357,10 +357,10 @@ var SolvaPayProvider = ({
     const interval = setInterval(detectAuth, 5e3);
     return () => clearInterval(interval);
   }, [userId]);
-  const fetchSubscription = (0, import_react.useCallback)(
+  const fetchPurchase = (0, import_react.useCallback)(
     async (force = false) => {
       if (!isAuthenticated && !internalCustomerRef) {
-        setSubscriptionData({ subscriptions: [] });
+        setPurchaseData({ purchases: [] });
         setLoading(false);
         inFlightRef.current = null;
         lastFetchedRef.current = null;
@@ -376,9 +376,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) {
@@ -390,16 +390,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;
         }
@@ -412,23 +412,23 @@ var SolvaPayProvider = ({
     },
     [isAuthenticated, internalCustomerRef, userId]
   );
-  const fetchSubscriptionRef = (0, import_react.useRef)(fetchSubscription);
+  const fetchPurchaseRef = (0, import_react.useRef)(fetchPurchase);
   (0, import_react.useEffect)(() => {
-    fetchSubscriptionRef.current = fetchSubscription;
-  }, [fetchSubscription]);
-  const refetchSubscription = (0, import_react.useCallback)(async () => {
+    fetchPurchaseRef.current = fetchPurchase;
+  }, [fetchPurchase]);
+  const refetchPurchase = (0, import_react.useCallback)(async () => {
     lastFetchedRef.current = null;
     inFlightRef.current = null;
-    setSubscriptionData({ subscriptions: [] });
-    await fetchSubscriptionRef.current(true);
+    setPurchaseData({ purchases: [] });
+    await fetchPurchaseRef.current(true);
   }, []);
   (0, import_react.useEffect)(() => {
     lastFetchedRef.current = null;
     inFlightRef.current = null;
     if (isAuthenticated || internalCustomerRef) {
-      fetchSubscription();
+      fetchPurchase();
     } else {
-      setSubscriptionData({ subscriptions: [] });
+      setPurchaseData({ purchases: [] });
       setLoading(false);
     }
   }, [isAuthenticated, internalCustomerRef, userId]);
@@ -436,49 +436,49 @@ var SolvaPayProvider = ({
     (newCustomerRef) => {
       setInternalCustomerRef(newCustomerRef);
       setCachedCustomerRef(newCustomerRef, userId);
-      fetchSubscription(true);
+      fetchPurchase(true);
     },
-    [fetchSubscription, userId]
+    [fetchPurchase, userId]
   );
-  const subscription = (0, import_react.useMemo)(() => {
-    const activeSubscription = getPrimarySubscription(subscriptionData.subscriptions);
-    const activePaidSubscriptions = subscriptionData.subscriptions.filter(
-      (sub) => sub.status === "active" && isPaidSubscription(sub)
+  const purchase = (0, import_react.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 = (0, import_react.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
     ]
@@ -511,7 +511,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] = (0, import_react3.useState)(false);
   const [error, setError] = (0, import_react3.useState)(
@@ -532,7 +533,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");
       }
@@ -561,7 +562,7 @@ function useCheckout(planRef, agentRef) {
       setLoading(false);
       isStartingRef.current = false;
     }
-  }, [planRef, agentRef, createPayment, updateCustomerRef, loading]);
+  }, [planRef, productRef, createPayment, updateCustomerRef, loading]);
   const reset = (0, import_react3.useCallback)(() => {
     isStartingRef.current = false;
     setLoading(false);
@@ -579,12 +580,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
   };
 }
 
@@ -629,12 +630,12 @@ var import_react_stripe_js = require("@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
   };
 }
 
@@ -807,7 +808,7 @@ var StripePaymentFormWrapper = ({
 var import_jsx_runtime4 = require("react/jsx-runtime");
 var PaymentForm = ({
   planRef,
-  agentRef,
+  productRef,
   onSuccess,
   onError,
   returnUrl,
@@ -822,8 +823,8 @@ var PaymentForm = ({
     clientSecret,
     startCheckout,
     stripePromise
-  } = useCheckout(validPlanRef, agentRef);
-  const { refetch } = useSubscription();
+  } = useCheckout({ planRef: validPlanRef, productRef });
+  const { refetch } = usePurchase();
   const { processPayment } = useSolvaPay();
   const hasInitializedRef = (0, import_react5.useRef)(false);
   (0, import_react5.useEffect)(() => {
@@ -842,11 +843,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;
@@ -863,6 +864,7 @@ var PaymentForm = ({
                 ...paymentIntentAny,
                 _processingTimeout: processingTimeout,
                 _processingResult: processingResult
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
               });
             }
             throw new Error("Payment processing timed out");
@@ -876,6 +878,7 @@ var PaymentForm = ({
               await onSuccess({
                 ...paymentIntentAny,
                 _processingError: error
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
               });
             } catch {
             }
@@ -890,10 +893,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 = (0, import_react5.useCallback)(
     (err) => {
@@ -981,13 +985,13 @@ var PlanBadge = ({
   as: Component = "div",
   className
 }) => {
-  const { subscriptions, loading, hasPaidSubscription, activeSubscription } = useSubscription();
+  const { purchases, loading, hasPaidPurchase, activePurchase } = usePurchase();
   const [displayPlan, setDisplayPlan] = (0, import_react6.useState)(null);
   const [hasLoadedOnce, setHasLoadedOnce] = (0, import_react6.useState)(false);
   const lastPlanRef = (0, import_react6.useRef)(null);
   const lastLoadingRef = (0, import_react6.useRef)(true);
-  const previousSubscriptionsRef = (0, import_react6.useRef)(subscriptions);
-  const currentPlanName = activeSubscription?.planName || null;
+  const previousPurchasesRef = (0, import_react6.useRef)(purchases);
+  const currentPlanName = activePurchase?.planName || null;
   const effectivePlanName = currentPlanName;
   (0, import_react6.useEffect)(() => {
     if (!loading && !hasLoadedOnce) {
@@ -996,16 +1000,16 @@ var PlanBadge = ({
     lastLoadingRef.current = loading;
   }, [loading, hasLoadedOnce]);
   (0, import_react6.useEffect)(() => {
-    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]);
   (0, import_react6.useEffect)(() => {
     const currentPlan = effectivePlanName;
     const previousPlan = lastPlanRef.current;
@@ -1024,19 +1028,19 @@ var PlanBadge = ({
   const shouldShow = effectivePlanName !== null && hasLoadedOnce;
   const planToDisplay = displayPlan ?? effectivePlanName;
   if (children) {
-    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, { children: children({ subscriptions, loading, displayPlan: planToDisplay, shouldShow }) });
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, { 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__ */ (0, import_jsx_runtime5.jsx)(
     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,
@@ -1046,14 +1050,14 @@ var PlanBadge = ({
   );
 };
 
-// src/components/SubscriptionGate.tsx
+// src/components/PurchaseGate.tsx
 var import_jsx_runtime6 = require("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__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children: children({
     hasAccess,
-    subscriptions,
+    purchases,
     loading
   }) });
 };
@@ -1066,7 +1070,7 @@ var import_react7 = require("react");
 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] = (0, import_react7.useState)([]);
   const [loading, setLoading] = (0, import_react7.useState)(true);
   const [error, setError] = (0, import_react7.useState)(null);
@@ -1089,12 +1093,12 @@ function usePlans(options) {
   }, [autoSelectFirstPaid]);
   const fetchPlans = (0, import_react7.useCallback)(
     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;
@@ -1135,14 +1139,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
@@ -1157,13 +1161,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]
   );
   (0, import_react7.useEffect)(() => {
     fetchPlans();
@@ -1196,16 +1200,16 @@ function usePlans(options) {
 // src/components/PlanSelector.tsx
 var import_jsx_runtime7 = require("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,
@@ -1219,46 +1223,46 @@ var PlanSelector = ({
     },
     [plans]
   );
-  const activeSubscription = (0, import_react8.useMemo)(() => {
-    const activeSubs = subscriptions.filter((sub) => sub.status === "active");
-    return activeSubs.sort(
+  const activePurchase = (0, import_react8.useMemo)(() => {
+    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 = (0, import_react8.useCallback)(
     (planName) => {
-      return activeSubscription?.planName === planName;
+      return activePurchase?.planName === planName;
     },
-    [activeSubscription]
+    [activePurchase]
   );
   return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_jsx_runtime7.Fragment, { children: children({
     ...plansHook,
-    subscriptions,
+    purchases,
     isPaidPlan,
     isCurrentPlan
   }) });
 };
 
-// src/hooks/useSubscriptionStatus.ts
+// src/hooks/usePurchaseStatus.ts
 var import_react9 = require("react");
-function useSubscriptionStatus() {
-  const { subscriptions } = useSubscription();
-  const isPaidSubscription2 = (0, import_react9.useCallback)((sub) => {
-    return (sub.amount ?? 0) > 0;
+function usePurchaseStatus() {
+  const { purchases } = usePurchase();
+  const isPaidPurchase2 = (0, import_react9.useCallback)((p) => {
+    return (p.amount ?? 0) > 0;
   }, []);
-  const subscriptionData = (0, import_react9.useMemo)(() => {
-    const cancelledPaidSubscriptions = subscriptions.filter((sub) => {
-      return sub.status === "active" && sub.cancelledAt && isPaidSubscription2(sub);
+  const purchaseData = (0, import_react9.useMemo)(() => {
+    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 = (0, import_react9.useCallback)((dateString) => {
     if (!dateString) return null;
     return new Date(dateString).toLocaleDateString("en-US", {
@@ -1276,8 +1280,8 @@ function useSubscriptionStatus() {
     return diffDays > 0 ? diffDays : 0;
   }, []);
   return {
-    cancelledSubscription: subscriptionData.cancelledSubscription,
-    shouldShowCancelledNotice: subscriptionData.shouldShowCancelledNotice,
+    cancelledPurchase: purchaseData.cancelledPurchase,
+    shouldShowCancelledNotice: purchaseData.shouldShowCancelledNotice,
     formatDate,
     getDaysUntilExpiration
   };
@@ -1287,21 +1291,21 @@ function useSubscriptionStatus() {
   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
 });