@umituz/react-native-subscription 2.41.4 → 2.41.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.41.4",
+  "version": "2.41.6",
   "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/domains/credits/application/PurchaseMetadataGenerator.ts

@@ -8,6 +8,9 @@ import type {
 import { detectPackageType } from "../../../utils/packageTypeDetector";
 import { PACKAGE_TYPE, PURCHASE_TYPE, type Platform } from "../../subscription/core/SubscriptionConstants";
 
+/** Maximum number of purchase history entries to retain per user */
+const MAX_PURCHASE_HISTORY_SIZE = 10;
+
 interface MetadataGeneratorConfig {
   productId: string;
   source: PurchaseSource;
@@ -44,7 +47,7 @@ export function generatePurchaseMetadata(
     timestamp: Timestamp.fromDate(new Date()),
   };
 
-  const purchaseHistory = [...existingData.purchaseHistory, newMetadata].slice(-10);
+  const purchaseHistory = [...existingData.purchaseHistory, newMetadata].slice(-MAX_PURCHASE_HISTORY_SIZE);
 
   return { purchaseType, purchaseHistory };
 }

package/src/domains/paywall/components/PaywallScreen.tsx

@@ -158,7 +158,7 @@ export const PaywallScreen: React.FC<PaywallScreenProps> = React.memo((props) =>
         return (
           <View key={`feat-${item.feature.text}`} style={[styles.featureRow, { marginHorizontal: 24, marginBottom: 16 }]}>
             <View style={[styles.featureIcon, { backgroundColor: tokens.colors.primary }]}>
-              <AtomicIcon name={item.feature.icon as any} customSize={16} customColor={tokens.colors.onPrimary} />
+              <AtomicIcon name={item.feature.icon} customSize={16} customColor={tokens.colors.onPrimary} />
             </View>
             <AtomicText type="bodyMedium" style={[styles.featureText, { color: tokens.colors.textPrimary }]}>
               {item.feature.text}

package/src/domains/subscription/infrastructure/utils/InitializationCache.ts

@@ -1,5 +1,5 @@
 interface CacheEntry {
-    promise: Promise<boolean>;
+    promise: Promise<boolean> | null;
     resolvedUserId: string | null;
     completed: boolean;
 }
@@ -18,7 +18,7 @@ export class InitializationCache {
 
     setPromise(promise: Promise<boolean>, cacheKey: string, realUserId: string | null): void {
         const entry: CacheEntry = {
-            promise: null as any, // Placeholder to be assigned immediately
+            promise: null,
             resolvedUserId: realUserId,
             completed: false,
         };

package/src/domains/subscription/presentation/components/ManagedSubscriptionFlow.tsx

@@ -76,7 +76,7 @@ import {
 } from "../providers/SubscriptionFlowProvider";
 import { SubscriptionFlowStatus } from "../useSubscriptionFlow";
 
-const ManagedSubscriptionFlowInner: React.FC<ManagedSubscriptionFlowProps> = ({
+const ManagedSubscriptionFlowInner = React.memo<ManagedSubscriptionFlowProps>(({
   children,
   navigation,
   islocalizationReady,
@@ -198,7 +198,7 @@ const ManagedSubscriptionFlowInner: React.FC<ManagedSubscriptionFlowProps> = ({
       )}
     </>
   );
-};
+});
 
 export const ManagedSubscriptionFlow: React.FC<ManagedSubscriptionFlowProps> = (props) => {
   return (

package/src/domains/subscription/presentation/providers/SubscriptionFlowProvider.tsx

@@ -9,68 +9,71 @@ interface SubscriptionFlowContextType {
 const SubscriptionFlowContext = createContext<SubscriptionFlowContextType | undefined>(undefined);
 
 export const SubscriptionFlowProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
-  const store = useSubscriptionFlowStore();
+  // Selectors for stable references and only what we need
+  const isInitialized = useSubscriptionFlowStore((state) => state.isInitialized);
+  const isOnboardingComplete = useSubscriptionFlowStore((state) => state.isOnboardingComplete);
+  const showPostOnboardingPaywall = useSubscriptionFlowStore((state) => state.showPostOnboardingPaywall);
+  const status = useSubscriptionFlowStore((state) => state.status);
+  const setInitialized = useSubscriptionFlowStore((state) => state.setInitialized);
+  const setStatus = useSubscriptionFlowStore((state) => state.setStatus);
 
   useEffect(() => {
     // 1. Listen to background initialization state
     const unsubscribe = initializationState.subscribe(() => {
       const { initialized } = initializationState.getSnapshot();
       if (__DEV__) {
-        console.log('[SubscriptionFlowProvider] 🔄 Initialization state updated:', { initialized });
+        console.log('[SubscriptionFlowProvider] 🔄 Initialization status updated:', { initialized });
       }
-      if (initialized && !store.isInitialized) {
-        store.setInitialized(true);
+      if (initialized && !isInitialized) {
+        setInitialized(true);
       }
     });
 
     // Check initial state
-    const { initialized } = initializationState.getSnapshot();
-    if (initialized && !store.isInitialized) {
+    const { initialized: currentlyInitialized } = initializationState.getSnapshot();
+    if (currentlyInitialized && !isInitialized) {
       if (__DEV__) console.log('[SubscriptionFlowProvider] ✅ Already initialized on mount');
-      store.setInitialized(true);
+      setInitialized(true);
     }
 
     return () => unsubscribe();
-  }, [store.isInitialized, store.setInitialized]);
+  }, [isInitialized, setInitialized]);
 
   useEffect(() => {
     // This effect manages the overall flow status transition
     if (__DEV__) {
        console.log('[SubscriptionFlowProvider] 🧠 Calculating Status Transition', {
-         isInitialized: store.isInitialized,
-         isOnboardingComplete: store.isOnboardingComplete,
-         showPostOnboardingPaywall: store.showPostOnboardingPaywall,
-         currentStatus: store.status
+         isInitialized,
+         isOnboardingComplete,
+         showPostOnboardingPaywall,
+         currentStatus: status
        });
     }
 
-    if (!store.isInitialized) {
-      store.setStatus(SubscriptionFlowStatus.INITIALIZING);
-      return;
-    }
+    let nextStatus = SubscriptionFlowStatus.READY;
 
-    if (!store.isOnboardingComplete) {
-      store.setStatus(SubscriptionFlowStatus.ONBOARDING);
-      return;
+    if (!isInitialized) {
+      nextStatus = SubscriptionFlowStatus.INITIALIZING;
+    } else if (!isOnboardingComplete) {
+      nextStatus = SubscriptionFlowStatus.ONBOARDING;
+    } else if (showPostOnboardingPaywall) {
+      nextStatus = SubscriptionFlowStatus.POST_ONBOARDING_PAYWALL;
     }
 
-    if (store.showPostOnboardingPaywall) {
-      store.setStatus(SubscriptionFlowStatus.POST_ONBOARDING_PAYWALL);
-      return;
+    if (nextStatus !== status) {
+       if (__DEV__) console.log('[SubscriptionFlowProvider] 🚀 Transitioning status to:', nextStatus);
+       setStatus(nextStatus);
     }
-
-    if (__DEV__) console.log('[SubscriptionFlowProvider] 🏆 Flow is READY');
-    store.setStatus(SubscriptionFlowStatus.READY);
   }, [
-    store.isInitialized,
-    store.isOnboardingComplete,
-    store.showPostOnboardingPaywall,
-    store.paywallShown,
-    store
+    isInitialized,
+    isOnboardingComplete,
+    showPostOnboardingPaywall,
+    status,
+    setStatus
   ]);
 
   return (
-    <SubscriptionFlowContext.Provider value={{ status: store.status }}>
+    <SubscriptionFlowContext.Provider value={{ status: status }}>
       {children}
     </SubscriptionFlowContext.Provider>
   );

package/src/domains/subscription/presentation/useSubscriptionFlow.ts

@@ -93,8 +93,14 @@ export const useSubscriptionFlowStore = createStore<SubscriptionFlowState, Subsc
     setAuthModalOpen: (open: boolean) => set({ isAuthModalOpen: open }),
     setShowFeedback: (show: boolean) => set({ showFeedback: show }),
     markPaywallShown: async () => set({ paywallShown: true }),
-    setInitialized: (initialized: boolean) => set({ isInitialized: initialized }),
-    setStatus: (status: SubscriptionFlowStatus) => set({ status }),
+    setInitialized: (initialized: boolean) => set((state) => {
+      if (state.isInitialized === initialized) return state;
+      return { isInitialized: initialized };
+    }),
+    setStatus: (status: SubscriptionFlowStatus) => set((state) => {
+      if (state.status === status) return state;
+      return { status };
+    }),
     setSyncStatus: (syncStatus: SyncStatus, syncError: string | null = null) => 
       set({ syncStatus, syncError }),
     resetFlow: async () => {