@umituz/react-native-subscription 2.9.7 → 2.10.0

package/package.json

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

@@ -239,6 +239,22 @@ export {
   type UseCreditCheckerResult,
 } from "./presentation/hooks/useCreditChecker";
 
+export {
+  usePaywallVisibility,
+  type UsePaywallVisibilityResult,
+} from "./presentation/hooks/usePaywallVisibility";
+
+export {
+  usePremiumWithConfig,
+  type UsePremiumWithConfigParams,
+  type UsePremiumWithConfigResult,
+} from "./presentation/hooks/usePremiumWithConfig";
+
+export {
+  useAuthSubscriptionSync,
+  type AuthSubscriptionSyncConfig,
+} from "./presentation/hooks/useAuthSubscriptionSync";
+
 // =============================================================================
 // CREDITS SYSTEM - Utilities
 // =============================================================================

package/src/presentation/hooks/useAuthSubscriptionSync.ts

@@ -0,0 +1,56 @@
+/**
+ * useAuthSubscriptionSync Hook
+ * Single source of truth for RevenueCat initialization
+ * Handles initial setup and auth state transitions
+ * Generic implementation for 100+ apps with auth provider abstraction
+ */
+
+import { useEffect, useRef, useCallback } from "react";
+
+export interface AuthSubscriptionSyncConfig {
+  /** Function to subscribe to auth state changes - returns unsubscribe function */
+  onAuthStateChanged: (callback: (userId: string | null) => void) => () => void;
+  /** Function to initialize subscription for a user */
+  initializeSubscription: (userId: string) => Promise<void>;
+}
+
+export function useAuthSubscriptionSync(
+  config: AuthSubscriptionSyncConfig,
+): void {
+  const { onAuthStateChanged, initializeSubscription } = config;
+  const previousUserIdRef = useRef<string | null>(null);
+  const isInitializedRef = useRef(false);
+
+  const initialize = useCallback(
+    async (userId: string) => {
+      await initializeSubscription(userId);
+    },
+    [initializeSubscription],
+  );
+
+  useEffect(() => {
+    const unsubscribe = onAuthStateChanged(async (userId: string | null) => {
+      if (!userId) {
+        previousUserIdRef.current = null;
+        return;
+      }
+
+      const previousUserId = previousUserIdRef.current;
+
+      if (userId === previousUserId) {
+        return;
+      }
+
+      if (previousUserId && previousUserId !== userId) {
+        await initialize(userId);
+      } else if (!isInitializedRef.current) {
+        await initialize(userId);
+        isInitializedRef.current = true;
+      }
+
+      previousUserIdRef.current = userId;
+    });
+
+    return () => unsubscribe();
+  }, [onAuthStateChanged, initialize]);
+}

package/src/presentation/hooks/usePaywallVisibility.ts

@@ -0,0 +1,54 @@
+/**
+ * Paywall Visibility Hook
+ * Simple global state for paywall visibility using module-level state
+ * Generic implementation for 100+ apps
+ */
+
+import { useCallback, useSyncExternalStore } from "react";
+
+type Listener = () => void;
+
+let paywallVisible = false;
+const listeners = new Set<Listener>();
+
+const subscribe = (listener: Listener): (() => void) => {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+};
+
+const getSnapshot = (): boolean => paywallVisible;
+
+const setPaywallVisible = (visible: boolean): void => {
+  paywallVisible = visible;
+  listeners.forEach((listener) => listener());
+};
+
+export interface UsePaywallVisibilityResult {
+  showPaywall: boolean;
+  setShowPaywall: (visible: boolean) => void;
+  openPaywall: () => void;
+  closePaywall: () => void;
+}
+
+export function usePaywallVisibility(): UsePaywallVisibilityResult {
+  const showPaywall = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+
+  const setShowPaywall = useCallback((visible: boolean) => {
+    setPaywallVisible(visible);
+  }, []);
+
+  const openPaywall = useCallback(() => {
+    setPaywallVisible(true);
+  }, []);
+
+  const closePaywall = useCallback(() => {
+    setPaywallVisible(false);
+  }, []);
+
+  return {
+    showPaywall,
+    setShowPaywall,
+    openPaywall,
+    closePaywall,
+  };
+}

package/src/presentation/hooks/usePremiumWithConfig.ts

@@ -0,0 +1,97 @@
+/**
+ * usePremiumWithConfig Hook
+ * Premium status from TanStack Query (credits)
+ * Subscription state from TanStack Query
+ * Generic implementation for 100+ apps with auth provider abstraction
+ */
+
+import { useCallback } from "react";
+import type { PurchasesPackage } from "react-native-purchases";
+import { useCredits } from "./useCredits";
+import { useInitializeCredits } from "./useDeductCredit";
+import {
+  useSubscriptionPackages,
+  usePurchasePackage,
+  useRestorePurchase,
+} from "../../revenuecat/presentation/hooks/useSubscriptionQueries";
+import { usePaywallVisibility } from "./usePaywallVisibility";
+
+export interface UsePremiumWithConfigParams {
+  /** Function to get current user ID (can be from Firebase, Supabase, etc.) */
+  getUserId: () => string | null | undefined;
+  /** Enable/disable credits query */
+  enabled?: boolean;
+}
+
+export interface UsePremiumWithConfigResult {
+  isPremium: boolean;
+  isLoading: boolean;
+  packages: PurchasesPackage[];
+  credits: any; // UserCredits from subscription package
+  showPaywall: boolean;
+  purchasePackage: (pkg: PurchasesPackage) => Promise<boolean>;
+  restorePurchase: () => Promise<boolean>;
+  setShowPaywall: (show: boolean) => void;
+  closePaywall: () => void;
+  openPaywall: () => void;
+}
+
+export const usePremiumWithConfig = (
+  params: UsePremiumWithConfigParams,
+): UsePremiumWithConfigResult => {
+  const { getUserId, enabled = true } = params;
+  const userId = getUserId();
+
+  const { credits, isLoading: creditsLoading } = useCredits({
+    userId,
+    enabled: enabled && !!userId,
+  });
+
+  const { initializeCredits } = useInitializeCredits({ userId });
+
+  const { data: packages = [], isLoading: packagesLoading } =
+    useSubscriptionPackages(userId);
+  const purchaseMutation = usePurchasePackage(userId);
+  const restoreMutation = useRestorePurchase(userId);
+
+  const { showPaywall, setShowPaywall, closePaywall, openPaywall } =
+    usePaywallVisibility();
+
+  const isPremium = credits !== null;
+
+  const handlePurchase = useCallback(
+    async (pkg: PurchasesPackage): Promise<boolean> => {
+      const success = await purchaseMutation.mutateAsync(pkg);
+      if (success && userId) {
+        await initializeCredits();
+      }
+      return success;
+    },
+    [purchaseMutation, userId, initializeCredits],
+  );
+
+  const handleRestore = useCallback(async (): Promise<boolean> => {
+    const success = await restoreMutation.mutateAsync();
+    if (success && userId) {
+      await initializeCredits();
+    }
+    return success;
+  }, [restoreMutation, userId, initializeCredits]);
+
+  return {
+    isPremium,
+    isLoading:
+      creditsLoading ||
+      packagesLoading ||
+      purchaseMutation.isPending ||
+      restoreMutation.isPending,
+    packages,
+    credits,
+    showPaywall,
+    purchasePackage: handlePurchase,
+    restorePurchase: handleRestore,
+    setShowPaywall,
+    closePaywall,
+    openPaywall,
+  };
+};