@umituz/react-native-subscription 2.26.12 → 2.26.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.26.12",
+  "version": "2.26.14",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/presentation/hooks/useCreditsGate.ts

@@ -2,61 +2,62 @@
  * useCreditsGate Hook
  *
  * Single responsibility: Credits gating
- * Checks if user has enough credits before allowing actions.
- *
- * @example
- * ```typescript
- * const { requireCredits, hasCredits } = useCreditsGate({
- *   hasCredits: canAfford(cost),
- *   creditBalance: credits,
- *   requiredCredits: cost,
- *   onCreditsRequired: (required) => showPaywall(required),
- * });
- *
- * const handleGenerate = () => {
- *   requireCredits(() => generate());
- * };
- * ```
+ * Uses ref pattern to avoid stale closure issues.
  */
 
-import { useCallback } from "react";
+import { useCallback, useRef, useEffect } from "react";
+
+declare const __DEV__: boolean;
 
 export interface UseCreditsGateParams {
-  /** Whether user has enough credits for the action */
-  hasCredits: boolean;
-  /** Current credit balance */
-  creditBalance: number;
-  /** Credits required for this action (optional, for display) */
-  requiredCredits?: number;
-  /** Callback when credits are required - receives required amount */
-  onCreditsRequired: (requiredCredits?: number) => void;
+  readonly creditBalance: number;
+  readonly requiredCredits?: number;
+  readonly onCreditsRequired: (requiredCredits?: number) => void;
 }
 
 export interface UseCreditsGateResult {
-  /** Whether user has enough credits */
-  hasCredits: boolean;
-  /** Current credit balance */
-  creditBalance: number;
-  /** Gate action behind credits - executes if has credits, else shows paywall */
-  requireCredits: (action: () => void | Promise<void>) => boolean;
+  readonly hasCredits: boolean;
+  readonly creditBalance: number;
+  readonly requireCredits: () => boolean;
 }
 
 export function useCreditsGate(
   params: UseCreditsGateParams
 ): UseCreditsGateResult {
-  const { hasCredits, creditBalance, requiredCredits, onCreditsRequired } =
-    params;
+  const { creditBalance, requiredCredits = 1, onCreditsRequired } = params;
+
+  const creditBalanceRef = useRef(creditBalance);
+  const onCreditsRequiredRef = useRef(onCreditsRequired);
+
+  useEffect(() => {
+    creditBalanceRef.current = creditBalance;
+  }, [creditBalance]);
+
+  useEffect(() => {
+    onCreditsRequiredRef.current = onCreditsRequired;
+  }, [onCreditsRequired]);
+
+  const hasCredits = creditBalance >= requiredCredits;
+
+  const requireCredits = useCallback((): boolean => {
+    const currentBalance = creditBalanceRef.current;
+    const canAfford = currentBalance >= requiredCredits;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[useCreditsGate] requireCredits", {
+        currentBalance,
+        requiredCredits,
+        canAfford,
+      });
+    }
+
+    if (!canAfford) {
+      onCreditsRequiredRef.current(requiredCredits);
+      return false;
+    }
 
-  const requireCredits = useCallback(
-    (_action: () => void | Promise<void>): boolean => {
-      if (!hasCredits) {
-        onCreditsRequired(requiredCredits);
-        return false;
-      }
-      return true;
-    },
-    [hasCredits, requiredCredits, onCreditsRequired]
-  );
+    return true;
+  }, [requiredCredits]);
 
   return {
     hasCredits,

package/src/presentation/hooks/useFeatureGate.ts

@@ -1,6 +1,7 @@
 /**
  * useFeatureGate Hook
  * Combines auth, subscription, and credits gates into a unified feature gate.
+ * Uses ref pattern to avoid stale closure issues.
  */
 
 import { useCallback, useRef, useEffect } from "react";
@@ -10,38 +11,22 @@ import { useCreditsGate } from "./useCreditsGate";
 
 declare const __DEV__: boolean;
 
-
-
 export interface UseFeatureGateParams {
-  /** Whether user is authenticated (not guest/anonymous) */
-  isAuthenticated: boolean;
-  /** Callback to show auth modal with pending action */
-  onShowAuthModal: (pendingCallback: () => void | Promise<void>) => void;
-  /** Whether user has active subscription (optional, defaults to false) */
-  hasSubscription?: boolean;
-  /** Whether user has enough credits for the action */
-  hasCredits: boolean;
-  /** Current credit balance */
-  creditBalance: number;
-  /** Credits required for this action (optional, for paywall display) */
-  requiredCredits?: number;
-  /** Callback to show paywall - receives required credits */
-  onShowPaywall: (requiredCredits?: number) => void;
+  readonly isAuthenticated: boolean;
+  readonly onShowAuthModal: (pendingCallback: () => void | Promise<void>) => void;
+  readonly hasSubscription?: boolean;
+  readonly creditBalance: number;
+  readonly requiredCredits?: number;
+  readonly onShowPaywall: (requiredCredits?: number) => void;
 }
 
 export interface UseFeatureGateResult {
-  /** Gate a feature - checks auth, subscription, then credits */
-  requireFeature: (action: () => void | Promise<void>) => void;
-  /** Whether user is authenticated */
-  isAuthenticated: boolean;
-  /** Whether user has active subscription */
-  hasSubscription: boolean;
-  /** Whether user has enough credits */
-  hasCredits: boolean;
-  /** Current credit balance */
-  creditBalance: number;
-  /** Whether feature access is allowed */
-  canAccess: boolean;
+  readonly requireFeature: (action: () => void | Promise<void>) => void;
+  readonly isAuthenticated: boolean;
+  readonly hasSubscription: boolean;
+  readonly hasCredits: boolean;
+  readonly creditBalance: number;
+  readonly canAccess: boolean;
 }
 
 export function useFeatureGate(
@@ -51,25 +36,22 @@ export function useFeatureGate(
     isAuthenticated,
     onShowAuthModal,
     hasSubscription = false,
-    hasCredits,
     creditBalance,
-    requiredCredits,
+    requiredCredits = 1,
     onShowPaywall,
   } = params;
 
-  // Store pending action for execution after purchase
   const pendingActionRef = useRef<(() => void | Promise<void>) | null>(null);
   const prevCreditBalanceRef = useRef(creditBalance);
   const isWaitingForPurchaseRef = useRef(false);
 
-  // Refs to always get current values in closures
-  const hasCreditsRef = useRef(hasCredits);
+  const creditBalanceRef = useRef(creditBalance);
   const hasSubscriptionRef = useRef(hasSubscription);
   const onShowPaywallRef = useRef(onShowPaywall);
 
   useEffect(() => {
-    hasCreditsRef.current = hasCredits;
-  }, [hasCredits]);
+    creditBalanceRef.current = creditBalance;
+  }, [creditBalance]);
 
   useEffect(() => {
     hasSubscriptionRef.current = hasSubscription;
@@ -79,11 +61,9 @@ export function useFeatureGate(
     onShowPaywallRef.current = onShowPaywall;
   }, [onShowPaywall]);
 
-  // Execute pending action when credits increase after purchase
   useEffect(() => {
-    const prevBalance = prevCreditBalanceRef.current ?? 0; // ← FIX: Default to 0 if undefined
-    const currentBalance = creditBalance;
-    const creditsIncreased = currentBalance > prevBalance;
+    const prevBalance = prevCreditBalanceRef.current ?? 0;
+    const creditsIncreased = creditBalance > prevBalance;
 
     if (isWaitingForPurchaseRef.current && creditsIncreased && pendingActionRef.current) {
       const action = pendingActionRef.current;
@@ -91,11 +71,7 @@ export function useFeatureGate(
       isWaitingForPurchaseRef.current = false;
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useFeatureGate] Credits increased, executing pending action", {
-          prevBalance,
-          currentBalance,
-          creditsIncreased,
-        });
+        console.log("[useFeatureGate] Credits increased, executing pending action");
       }
       action();
     }
@@ -103,7 +79,6 @@ export function useFeatureGate(
     prevCreditBalanceRef.current = creditBalance;
   }, [creditBalance]);
 
-  // Compose individual gates
   const authGate = useAuthGate({
     isAuthenticated,
     onAuthRequired: onShowAuthModal,
@@ -115,7 +90,6 @@ export function useFeatureGate(
   });
 
   const creditsGate = useCreditsGate({
-    hasCredits,
     creditBalance,
     requiredCredits,
     onCreditsRequired: onShowPaywall,
@@ -123,85 +97,65 @@ export function useFeatureGate(
 
   const requireFeature = useCallback(
     (action: () => void | Promise<void>) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[useFeatureGate] requireFeature", {
+          isAuthenticated,
+          hasSubscription,
+          creditBalance: creditBalanceRef.current,
+          requiredCredits,
+        });
+      }
 
-      // Step 1: Auth check
       if (!authGate.requireAuth(() => {})) {
-        // Wrap action to re-check credits after auth succeeds
-        // Using refs to get current values when callback executes
         const postAuthAction = () => {
-          // Subscription check (bypasses credits if subscribed)
           if (hasSubscriptionRef.current) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.log("[useFeatureGate] User has subscription, executing action");
-            }
             action();
             return;
           }
 
-          // Credits check
-          if (!hasCreditsRef.current) {
+          const currentBalance = creditBalanceRef.current;
+          if (currentBalance < requiredCredits) {
             pendingActionRef.current = action;
             isWaitingForPurchaseRef.current = true;
             onShowPaywallRef.current(requiredCredits);
             return;
           }
 
-          // All checks passed
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[useFeatureGate] User has credits, executing action");
-          }
           action();
         };
         onShowAuthModal(postAuthAction);
         return;
       }
 
-      // Step 2: Subscription check (bypasses credits if subscribed)
       if (hasSubscription) {
         action();
         return;
       }
 
-      // Step 3: Credits check
-      if (!creditsGate.requireCredits(() => {})) {
-        // Store pending action for execution after purchase
+      if (!creditsGate.requireCredits()) {
         pendingActionRef.current = action;
         isWaitingForPurchaseRef.current = true;
         return;
       }
 
-      // Step 4: All checks passed, execute action
       action();
     },
-    [
-      authGate,
-      creditsGate,
-      hasSubscription,
-      requiredCredits,
-      onShowAuthModal,
-    ]
+    [authGate, creditsGate, hasSubscription, requiredCredits, isAuthenticated, onShowAuthModal]
   );
 
+  const hasCredits = creditBalance >= requiredCredits;
+
   return {
     requireFeature,
     isAuthenticated: authGate.isAuthenticated,
     hasSubscription: subscriptionGate.hasSubscription,
-    hasCredits: creditsGate.hasCredits,
-    creditBalance: creditsGate.creditBalance,
+    hasCredits,
+    creditBalance,
     canAccess: isAuthenticated && (hasSubscription || hasCredits),
   };
 }
 
 export { useAuthGate, useSubscriptionGate, useCreditsGate };
-export type {
-  UseAuthGateParams,
-  UseAuthGateResult,
-} from "./useAuthGate";
-export type {
-  UseSubscriptionGateParams,
-  UseSubscriptionGateResult,
-} from "./useSubscriptionGate";
-export type {
-  UseCreditsGateParams,
-  UseCreditsGateResult,
-} from "./useCreditsGate";
+export type { UseAuthGateParams, UseAuthGateResult } from "./useAuthGate";
+export type { UseSubscriptionGateParams, UseSubscriptionGateResult } from "./useSubscriptionGate";
+export type { UseCreditsGateParams, UseCreditsGateResult } from "./useCreditsGate";