@umituz/react-native-subscription 2.14.37 → 2.14.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.14.37",
+  "version": "2.14.38",
   "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/paywall/index.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./usePaywallRefs";
+export * from "./usePaywallOperations";

package/src/presentation/hooks/paywall/types.ts

@@ -0,0 +1,29 @@
+import type { PurchasesPackage } from "react-native-purchases";
+
+export type PurchaseSource = "inApp" | "postOnboarding" | null;
+
+export interface PaywallOperationsProps {
+  userId: string | undefined;
+  isAnonymous: boolean;
+  onPaywallClose?: () => void;
+  onPurchaseSuccess?: () => void;
+  onAuthRequired?: () => void;
+}
+
+export interface PaywallOperationsResult {
+  pendingPackage: PurchasesPackage | null;
+  handlePurchase: (pkg: PurchasesPackage) => Promise<boolean>;
+  handleRestore: () => Promise<boolean>;
+  handleInAppPurchase: (pkg: PurchasesPackage) => Promise<boolean>;
+  handleInAppRestore: () => Promise<boolean>;
+  completePendingPurchase: () => Promise<boolean>;
+  clearPendingPackage: () => void;
+}
+
+export interface PaywallRefs {
+  userIdRef: React.MutableRefObject<string | undefined>;
+  isAnonymousRef: React.MutableRefObject<boolean>;
+  purchasePackageRef: React.MutableRefObject<(pkg: PurchasesPackage) => Promise<boolean>>;
+  closePaywallRef: React.MutableRefObject<() => void>;
+  onPurchaseSuccessRef: React.MutableRefObject<(() => void) | undefined>;
+}

package/src/presentation/hooks/paywall/usePaywallOperations.ts

@@ -0,0 +1,140 @@
+import { useState, useCallback } from "react";
+import { Alert } from "react-native";
+import { useLocalization } from "@umituz/react-native-localization";
+import type { PurchasesPackage } from "react-native-purchases";
+import { usePremium } from "../usePremium";
+import { usePaywallRefs } from "./usePaywallRefs";
+import type {
+  PurchaseSource,
+  PaywallOperationsProps,
+  PaywallOperationsResult,
+} from "./types";
+
+const RERENDER_DELAY_MS = 100;
+
+export function usePaywallOperations({
+  userId,
+  isAnonymous,
+  onPaywallClose,
+  onPurchaseSuccess,
+  onAuthRequired,
+}: PaywallOperationsProps): PaywallOperationsResult {
+  const { t } = useLocalization();
+  const { purchasePackage, restorePurchase, closePaywall } = usePremium(userId);
+
+  const [pendingPackage, setPendingPackage] = useState<PurchasesPackage | null>(null);
+  const [pendingSource, setPendingSource] = useState<PurchaseSource>(null);
+
+  const refs = usePaywallRefs({
+    userId,
+    isAnonymous,
+    purchasePackage,
+    closePaywall,
+    onPurchaseSuccess,
+  });
+
+  const isAuthenticated = useCallback((): boolean => {
+    return !!refs.userIdRef.current && !refs.isAnonymousRef.current;
+  }, [refs]);
+
+  const showError = useCallback(() => {
+    Alert.alert(t("premium.purchaseError"), t("premium.purchaseErrorMessage"));
+  }, [t]);
+
+  const handlePurchase = useCallback(
+    async (pkg: PurchasesPackage): Promise<boolean> => {
+      if (!isAuthenticated()) {
+        setPendingPackage(pkg);
+        setPendingSource("postOnboarding");
+        onAuthRequired?.();
+        onPaywallClose?.();
+        return false;
+      }
+      const success = await purchasePackage(pkg);
+      if (success) onPurchaseSuccess?.();
+      else showError();
+      return success;
+    },
+    [isAuthenticated, purchasePackage, onPurchaseSuccess, onPaywallClose, onAuthRequired, showError]
+  );
+
+  const handleRestore = useCallback(async (): Promise<boolean> => {
+    const success = await restorePurchase();
+    Alert.alert(
+      success ? t("premium.restoreSuccess") : t("premium.restoreError"),
+      success ? t("premium.restoreMessage") : t("premium.restoreErrorMessage")
+    );
+    if (success) onPurchaseSuccess?.();
+    return success;
+  }, [restorePurchase, onPurchaseSuccess, t]);
+
+  const handleInAppPurchase = useCallback(
+    async (pkg: PurchasesPackage): Promise<boolean> => {
+      if (!isAuthenticated()) {
+        setPendingPackage(pkg);
+        setPendingSource("inApp");
+        onAuthRequired?.();
+        return false;
+      }
+      const success = await purchasePackage(pkg);
+      if (success) closePaywall();
+      else showError();
+      return success;
+    },
+    [isAuthenticated, purchasePackage, closePaywall, onAuthRequired, showError]
+  );
+
+  const handleInAppRestore = useCallback(async (): Promise<boolean> => {
+    const success = await restorePurchase();
+    Alert.alert(
+      success ? t("premium.restoreSuccess") : t("premium.restoreError"),
+      success ? t("premium.restoreMessage") : t("premium.restoreErrorMessage")
+    );
+    if (success) closePaywall();
+    return success;
+  }, [restorePurchase, closePaywall, t]);
+
+  const completePendingPurchase = useCallback(async (): Promise<boolean> => {
+    if (!pendingPackage) {
+      if (__DEV__) console.log("[usePaywallOperations] No pending package");
+      return false;
+    }
+
+    const pkg = pendingPackage;
+    const source = pendingSource;
+    setPendingPackage(null);
+    setPendingSource(null);
+
+    await new Promise((resolve) => setTimeout(resolve, RERENDER_DELAY_MS));
+
+    if (__DEV__) {
+      console.log("[usePaywallOperations] Completing:", pkg.identifier, source);
+    }
+
+    const success = await refs.purchasePackageRef.current(pkg);
+
+    if (success) {
+      source === "inApp"
+        ? refs.closePaywallRef.current()
+        : refs.onPurchaseSuccessRef.current?.();
+    } else {
+      showError();
+    }
+    return success;
+  }, [pendingPackage, pendingSource, refs, showError]);
+
+  const clearPendingPackage = useCallback(() => {
+    setPendingPackage(null);
+    setPendingSource(null);
+  }, []);
+
+  return {
+    pendingPackage,
+    handlePurchase,
+    handleRestore,
+    handleInAppPurchase,
+    handleInAppRestore,
+    completePendingPurchase,
+    clearPendingPackage,
+  };
+}

package/src/presentation/hooks/paywall/usePaywallRefs.ts

@@ -0,0 +1,53 @@
+import { useRef, useEffect } from "react";
+import type { PurchasesPackage } from "react-native-purchases";
+import type { PaywallRefs } from "./types";
+
+interface UsePaywallRefsProps {
+  userId: string | undefined;
+  isAnonymous: boolean;
+  purchasePackage: (pkg: PurchasesPackage) => Promise<boolean>;
+  closePaywall: () => void;
+  onPurchaseSuccess?: () => void;
+}
+
+export function usePaywallRefs({
+  userId,
+  isAnonymous,
+  purchasePackage,
+  closePaywall,
+  onPurchaseSuccess,
+}: UsePaywallRefsProps): PaywallRefs {
+  const userIdRef = useRef(userId);
+  const isAnonymousRef = useRef(isAnonymous);
+  const purchasePackageRef = useRef(purchasePackage);
+  const closePaywallRef = useRef(closePaywall);
+  const onPurchaseSuccessRef = useRef(onPurchaseSuccess);
+
+  useEffect(() => {
+    userIdRef.current = userId;
+  }, [userId]);
+
+  useEffect(() => {
+    isAnonymousRef.current = isAnonymous;
+  }, [isAnonymous]);
+
+  useEffect(() => {
+    purchasePackageRef.current = purchasePackage;
+  }, [purchasePackage]);
+
+  useEffect(() => {
+    closePaywallRef.current = closePaywall;
+  }, [closePaywall]);
+
+  useEffect(() => {
+    onPurchaseSuccessRef.current = onPurchaseSuccess;
+  }, [onPurchaseSuccess]);
+
+  return {
+    userIdRef,
+    isAnonymousRef,
+    purchasePackageRef,
+    closePaywallRef,
+    onPurchaseSuccessRef,
+  };
+}

package/src/presentation/hooks/usePaywallOperations.ts

@@ -1,218 +1,5 @@
-/**
- * Paywall Logic Hook
- *
- * Generic business logic for handling paywall interactions.
- * Decouples logic from UI and specific App implementations.
- * Follows "Package Driven Design" by accepting dynamic props.
- */
-
-import { useState, useCallback, useRef, useEffect } from "react";
-import { Alert } from "react-native";
-import { useLocalization } from "@umituz/react-native-localization";
-import { usePremium } from "./usePremium";
-import type { PurchasesPackage } from "react-native-purchases";
-
-export interface UsePaywallOperationsProps {
-    /** Current User ID (or undefined) */
-    userId: string | undefined;
-    /** Whether the user is anonymous/guest */
-    isAnonymous: boolean;
-    /** Callback when paywall should close (e.g. close button pressed) */
-    onPaywallClose?: () => void;
-    /** Callback when purchase completes successfully */
-    onPurchaseSuccess?: () => void;
-    /** Callback when authentication is required (e.g. for purchase) */
-    onAuthRequired?: () => void;
-}
-
-export interface UsePaywallOperationsResult {
-    /** Package that was pending purchase before auth interrupt */
-    pendingPackage: PurchasesPackage | null;
-    /** Handle purchasing a package */
-    handlePurchase: (pkg: PurchasesPackage) => Promise<boolean>;
-    /** Handle restoring purchases */
-    handleRestore: () => Promise<boolean>;
-    /** Handle in-app purchase (with auto-close logic) */
-    handleInAppPurchase: (pkg: PurchasesPackage) => Promise<boolean>;
-    /** Handle in-app restore (with auto-close logic) */
-    handleInAppRestore: () => Promise<boolean>;
-    /** Complete pending purchase after authentication */
-    completePendingPurchase: () => Promise<boolean>;
-    /** Clear pending package without purchasing */
-    clearPendingPackage: () => void;
-}
-
-export function usePaywallOperations({
-    userId,
-    isAnonymous,
-    onPaywallClose,
-    onPurchaseSuccess,
-    onAuthRequired,
-}: UsePaywallOperationsProps): UsePaywallOperationsResult {
-    const { t } = useLocalization();
-    const { purchasePackage, restorePurchase, closePaywall } = usePremium(userId);
-    const [pendingPackage, setPendingPackage] = useState<PurchasesPackage | null>(null);
-
-    // Ref to always have latest purchasePackage function (avoids stale closure)
-    const purchasePackageRef = useRef(purchasePackage);
-    const onPurchaseSuccessRef = useRef(onPurchaseSuccess);
-
-    useEffect(() => {
-        purchasePackageRef.current = purchasePackage;
-    }, [purchasePackage]);
-
-    useEffect(() => {
-        onPurchaseSuccessRef.current = onPurchaseSuccess;
-    }, [onPurchaseSuccess]);
-
-    /**
-     * Check if action requires authentication
-     * @returns true if authenticated, false if auth required
-     */
-    const checkAuth = useCallback((): boolean => {
-        if (!userId || isAnonymous) {
-            if (__DEV__) {
-                console.log("[usePaywallOperations] User not authenticated, triggering onAuthRequired");
-            }
-            if (onAuthRequired) {
-                onAuthRequired();
-            }
-            return false;
-        }
-        return true;
-    }, [userId, isAnonymous, onAuthRequired]);
-
-    /**
-     * Execute purchase flow with Alerts
-     */
-    const executePurchase = useCallback(
-        async (pkg: PurchasesPackage, onSuccess?: () => void): Promise<boolean> => {
-            // 1. Auth Check
-            if (!checkAuth()) {
-                setPendingPackage(pkg);
-                return false;
-            }
-
-            // 2. Purchase
-            const success = await purchasePackage(pkg);
-
-            // 3. Handle Result
-            if (success) {
-                if (onSuccess) onSuccess();
-            } else {
-                Alert.alert(
-                    t("premium.purchaseError"),
-                    t("premium.purchaseErrorMessage")
-                );
-            }
-            return success;
-        },
-        [checkAuth, purchasePackage, t]
-    );
-
-    /**
-     * Execute restore flow with Alerts
-     */
-    const executeRestore = useCallback(
-        async (onSuccess?: () => void): Promise<boolean> => {
-            // 1. Restore
-            const success = await restorePurchase();
-
-            // 2. Alert Result
-            Alert.alert(
-                success ? t("premium.restoreSuccess") : t("premium.restoreError"),
-                success
-                    ? t("premium.restoreMessage")
-                    : t("premium.restoreErrorMessage")
-            );
-
-            // 3. Handle Success
-            if (success) {
-                if (onSuccess) onSuccess();
-            }
-            return success;
-        },
-        [restorePurchase, t]
-    );
-
-    // ============================================================================
-    // Public Handlers
-    // ============================================================================
-
-    const handlePurchase = useCallback(
-        async (pkg: PurchasesPackage): Promise<boolean> => {
-            const result = await executePurchase(pkg, onPurchaseSuccess);
-            if (!result && !checkAuth()) {
-                if (onPaywallClose) onPaywallClose();
-            }
-            return result;
-        },
-        [executePurchase, onPurchaseSuccess, checkAuth, onPaywallClose]
-    );
-
-    const handleRestore = useCallback(
-        async (): Promise<boolean> => executeRestore(onPurchaseSuccess),
-        [executeRestore, onPurchaseSuccess]
-    );
-
-    const handleInAppPurchase = useCallback(
-        async (pkg: PurchasesPackage): Promise<boolean> => {
-            const result = await executePurchase(pkg, closePaywall);
-            if (!result && !checkAuth()) {
-                closePaywall();
-            }
-            return result;
-        },
-        [executePurchase, closePaywall, checkAuth]
-    );
-
-    const handleInAppRestore = useCallback(
-        async (): Promise<boolean> => executeRestore(closePaywall),
-        [executeRestore, closePaywall]
-    );
-
-    const completePendingPurchase = useCallback(async (): Promise<boolean> => {
-        if (!pendingPackage) {
-            if (__DEV__) {
-                console.log("[usePaywallOperations] No pending package to complete");
-            }
-            return false;
-        }
-
-        if (__DEV__) {
-            console.log("[usePaywallOperations] Completing pending purchase:", pendingPackage.identifier);
-        }
-
-        const pkg = pendingPackage;
-        setPendingPackage(null);
-
-        // Use ref to get latest purchasePackage (avoids stale closure after auth)
-        const success = await purchasePackageRef.current(pkg);
-
-        if (success) {
-            // Use ref to get latest callback
-            if (onPurchaseSuccessRef.current) onPurchaseSuccessRef.current();
-        } else {
-            Alert.alert(
-                t("premium.purchaseError"),
-                t("premium.purchaseErrorMessage")
-            );
-        }
-
-        return success;
-    }, [pendingPackage, t]);
-
-    const clearPendingPackage = useCallback(() => {
-        setPendingPackage(null);
-    }, []);
-
-    return {
-        pendingPackage,
-        handlePurchase,
-        handleRestore,
-        handleInAppPurchase,
-        handleInAppRestore,
-        completePendingPurchase,
-        clearPendingPackage,
-    };
-}
+export {
+  usePaywallOperations,
+  type PaywallOperationsProps as UsePaywallOperationsProps,
+  type PaywallOperationsResult as UsePaywallOperationsResult,
+} from "./paywall";