@umituz/react-native-subscription 2.10.9 → 2.10.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.10.9",
+  "version": "2.10.11",
   "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/components/paywall/SubscriptionPackageList.tsx

@@ -4,6 +4,7 @@ import { AtomicText } from "@umituz/react-native-design-system";
 import { useAppDesignTokens } from "@umituz/react-native-design-system";
 import type { PurchasesPackage } from "react-native-purchases";
 import { SubscriptionPlanCard } from "./SubscriptionPlanCard";
+import { isYearlyPackage } from "../../../utils/packagePeriodUtils";
 
 interface SubscriptionPackageListProps {
     isLoading: boolean;
@@ -12,6 +13,8 @@ interface SubscriptionPackageListProps {
     loadingText: string;
     emptyText: string;
     onSelect: (pkg: PurchasesPackage) => void;
+    /** Optional: Manually specify which package should show "Best Value" badge by identifier */
+    bestValueIdentifier?: string;
 }
 
 export const SubscriptionPackageList: React.FC<SubscriptionPackageListProps> = React.memo(
@@ -22,6 +25,7 @@ export const SubscriptionPackageList: React.FC<SubscriptionPackageListProps> = R
         loadingText,
         emptyText,
         onSelect,
+        bestValueIdentifier,
     }) => {
         const tokens = useAppDesignTokens();
         const hasPackages = packages.length > 0;
@@ -69,15 +73,28 @@ export const SubscriptionPackageList: React.FC<SubscriptionPackageListProps> = R
 
         return (
             <View style={styles.packagesContainer}>
-                {packages.map((pkg, index) => (
-                    <SubscriptionPlanCard
-                        key={pkg.product.identifier}
-                        package={pkg}
-                        isSelected={selectedPkg?.product.identifier === pkg.product.identifier}
-                        onSelect={() => onSelect(pkg)}
-                        isBestValue={index === 0}
-                    />
-                ))}
+                {packages.map((pkg) => {
+                    // Determine if this package should show "Best Value" badge
+                    let isBestValue = false;
+
+                    if (bestValueIdentifier) {
+                        // Use manual override if provided
+                        isBestValue = pkg.product.identifier === bestValueIdentifier;
+                    } else {
+                        // Auto-detect: mark yearly packages as best value
+                        isBestValue = isYearlyPackage(pkg);
+                    }
+
+                    return (
+                        <SubscriptionPlanCard
+                            key={pkg.product.identifier}
+                            package={pkg}
+                            isSelected={selectedPkg?.product.identifier === pkg.product.identifier}
+                            onSelect={() => onSelect(pkg)}
+                            isBestValue={isBestValue}
+                        />
+                    );
+                })}
             </View>
         );
     }

package/src/presentation/components/paywall/SubscriptionPlanCard.tsx

@@ -12,6 +12,7 @@ import { formatPrice } from "../../../utils/priceUtils";
 import { useLocalization } from "@umituz/react-native-localization";
 import { BestValueBadge } from "./BestValueBadge";
 
+import { getPeriodLabel, isYearlyPackage } from "../../../utils/packagePeriodUtils";
 // @ts-ignore
 import { LinearGradient } from "expo-linear-gradient";
 
@@ -22,26 +23,13 @@ interface SubscriptionPlanCardProps {
   isBestValue?: boolean;
 }
 
-const getPeriodLabel = (period: string | null | undefined): string => {
-  if (!period) return "";
-  if (period.includes("Y") || period.includes("year")) return "yearly";
-  if (period.includes("M") || period.includes("month")) return "monthly";
-  if (period.includes("W") || period.includes("week")) return "weekly";
-  if (period.includes("D") || period.includes("day")) return "daily";
-  return "";
-};
-
-const isYearlyPeriod = (period: string | null | undefined): boolean => {
-  return period?.includes("Y") || period?.includes("year") || false;
-};
-
 export const SubscriptionPlanCard: React.FC<SubscriptionPlanCardProps> =
   React.memo(({ package: pkg, isSelected, onSelect, isBestValue = false }) => {
     const tokens = useAppDesignTokens();
     const { t } = useLocalization();
 
     const period = pkg.product.subscriptionPeriod;
-    const isYearly = isYearlyPeriod(period);
+    const isYearly = isYearlyPackage(pkg);
     const periodLabel = getPeriodLabel(period);
     const price = formatPrice(pkg.product.price, pkg.product.currencyCode);
     const monthlyEquivalent = isYearly

package/src/revenuecat/infrastructure/managers/SubscriptionManager.ts

@@ -91,10 +91,6 @@ class SubscriptionManagerImpl {
       if (existingPromise) return existingPromise;
     }
 
-    if (this.initCache.shouldReinitialize(effectiveUserId) && this.serviceInstance) {
-      await this.serviceInstance.reset();
-    }
-
     const promise = this.performInitialization(effectiveUserId);
     this.initCache.setPromise(promise, effectiveUserId);
 
@@ -107,7 +103,7 @@ class SubscriptionManagerImpl {
 
   isInitializedForUser(userId: string): boolean {
     return this.serviceInstance?.isInitialized() === true &&
-           this.initCache.getCurrentUserId() === userId;
+      this.initCache.getCurrentUserId() === userId;
   }
 
   async getPackages(): Promise<PurchasesPackage[]> {

package/src/revenuecat/infrastructure/services/RevenueCatInitializer.ts

@@ -11,7 +11,6 @@ import { resolveApiKey } from "../utils/ApiKeyResolver";
 import {
   trackPackageError,
   addPackageBreadcrumb,
-  trackPackageWarning,
 } from "@umituz/react-native-sentry";
 
 export interface InitializerDeps {
@@ -23,6 +22,9 @@ export interface InitializerDeps {
   setCurrentUserId: (userId: string) => void;
 }
 
+// Track if Purchases.configure has been called globally
+let isPurchasesConfigured = false;
+
 export async function initializeSDK(
   deps: InitializerDeps,
   userId: string,
@@ -31,71 +33,66 @@ export async function initializeSDK(
   addPackageBreadcrumb("subscription", "SDK initialization started", {
     userId,
     hasApiKey: !!apiKey,
+    isAlreadyConfigured: isPurchasesConfigured,
   });
 
   if (__DEV__) {
-    console.log("[RevenueCat] initializeSDK() called with userId:", userId);
+    console.log("[RevenueCat] initializeSDK() called with userId:", userId, "isPurchasesConfigured:", isPurchasesConfigured);
   }
 
-  // Check if already initialized with same userId - skip re-configuration
-  if (deps.isInitialized()) {
-    const currentUserId = deps.getCurrentUserId();
-    if (currentUserId === userId) {
-      addPackageBreadcrumb("subscription", "Already initialized, fetching current state", {
-        userId,
-      });
+  // Case 1: Already initialized with the same user ID
+  if (deps.isInitialized() && deps.getCurrentUserId() === userId) {
+    if (__DEV__) {
+      console.log("[RevenueCat] Already initialized with same userId, skipping configure");
+    }
 
-      if (__DEV__) {
-        console.log("[RevenueCat] Already initialized with same userId, skipping configure");
-      }
-      // Just fetch current state without re-configuring
-      try {
-        const [customerInfo, offerings] = await Promise.all([
-          Purchases.getCustomerInfo(),
-          Purchases.getOfferings(),
-        ]);
-        const entitlementId = deps.config.entitlementIdentifier;
-        const hasPremium = !!customerInfo.entitlements.active[entitlementId];
-        return { success: true, offering: offerings.current, hasPremium };
-      } catch (error) {
-        trackPackageError(
-          error instanceof Error ? error : new Error(String(error)),
-          {
-            packageName: "subscription",
-            operation: "get_current_state",
-            userId,
-          }
-        );
-
-        if (__DEV__) {
-          console.log("[RevenueCat] Failed to get current state:", error);
+    try {
+      const [customerInfo, offerings] = await Promise.all([
+        Purchases.getCustomerInfo(),
+        Purchases.getOfferings(),
+      ]);
+      const entitlementId = deps.config.entitlementIdentifier;
+      const hasPremium = !!customerInfo.entitlements.active[entitlementId];
+      return { success: true, offering: offerings.current, hasPremium };
+    } catch (error) {
+      trackPackageError(
+        error instanceof Error ? error : new Error(String(error)),
+        {
+          packageName: "subscription",
+          operation: "get_current_state",
+          userId,
         }
-        return { success: false, offering: null, hasPremium: false };
-      }
-    } else {
-      addPackageBreadcrumb("subscription", "User changed, logging out previous user", {
-        previousUserId: currentUserId,
-        newUserId: userId,
-      });
-
-      if (__DEV__) {
-        console.log("[RevenueCat] Different userId, will re-configure");
-      }
-      // Different userId - need to logout first
-      try {
-        await Purchases.logOut();
-      } catch (error) {
-        trackPackageWarning("subscription", "Logout failed during user change", {
-          error: error instanceof Error ? error.message : String(error),
-          previousUserId: currentUserId,
-          newUserId: userId,
-        });
-      }
+      );
+      return { success: false, offering: null, hasPremium: false };
     }
   }
 
+  // Case 2: Already configured but different user or re-initializing
+  if (isPurchasesConfigured) {
+    if (__DEV__) {
+      console.log("[RevenueCat] SDK already configured, using logIn for userId:", userId);
+    }
+
+    try {
+      const { customerInfo } = await Purchases.logIn(userId);
+
+      deps.setInitialized(true);
+      deps.setCurrentUserId(userId);
 
+      const offerings = await Purchases.getOfferings();
+      const entitlementId = deps.config.entitlementIdentifier;
+      const hasPremium = !!customerInfo.entitlements.active[entitlementId];
+
+      return { success: true, offering: offerings.current, hasPremium };
+    } catch (error) {
+      if (__DEV__) console.warn("[RevenueCat] logIn failed:", error);
+      // If logIn fails, we don't necessarily want to re-configure if it's already configured
+      // But we can return failure
+      return { success: false, offering: null, hasPremium: false };
+    }
+  }
 
+  // Case 3: First time configuration
   const key = apiKey || resolveApiKey(deps.config);
   if (!key) {
     const error = new Error("No RevenueCat API key available");
@@ -104,38 +101,25 @@ export async function initializeSDK(
       operation: "sdk_init_no_key",
       userId,
     });
-
-    if (__DEV__) {
-      console.log("[RevenueCat] No API key available");
-    }
     return { success: false, offering: null, hasPremium: false };
   }
 
   try {
     if (deps.isUsingTestStore()) {
-      addPackageBreadcrumb("subscription", "Using test store configuration", {
-        userId,
-      });
-
       if (__DEV__) {
         console.log("[RevenueCat] Using Test Store key");
       }
     }
 
-    addPackageBreadcrumb("subscription", "Configuring SDK", { userId });
-
     if (__DEV__) {
       console.log("[RevenueCat] Calling Purchases.configure()...");
     }
 
     await Purchases.configure({ apiKey: key, appUserID: userId });
+    isPurchasesConfigured = true;
     deps.setInitialized(true);
     deps.setCurrentUserId(userId);
 
-    addPackageBreadcrumb("subscription", "SDK configured successfully", {
-      userId,
-    });
-
     if (__DEV__) {
       console.log("[RevenueCat] SDK configured successfully");
     }

package/src/utils/packagePeriodUtils.ts

@@ -0,0 +1,51 @@
+/**
+ * Package Period Utilities
+ * Helper functions for working with subscription periods
+ */
+
+import type { PurchasesPackage } from "react-native-purchases";
+
+/**
+ * Get period label from subscription period string
+ */
+export const getPeriodLabel = (period: string | null | undefined): string => {
+    if (!period) return "";
+    if (period.includes("Y") || period.includes("year")) return "yearly";
+    if (period.includes("M") || period.includes("month")) return "monthly";
+    if (period.includes("W") || period.includes("week")) return "weekly";
+    if (period.includes("D") || period.includes("day")) return "daily";
+    return "";
+};
+
+/**
+ * Check if a package has a yearly subscription period
+ */
+export const isYearlyPackage = (pkg: PurchasesPackage): boolean => {
+    const period = pkg.product.subscriptionPeriod;
+    return period?.includes("Y") || period?.includes("year") || false;
+};
+
+/**
+ * Check if a package has a monthly subscription period
+ */
+export const isMonthlyPackage = (pkg: PurchasesPackage): boolean => {
+    const period = pkg.product.subscriptionPeriod;
+    return period?.includes("M") || period?.includes("month") || false;
+};
+
+/**
+ * Check if a package has a weekly subscription period
+ */
+export const isWeeklyPackage = (pkg: PurchasesPackage): boolean => {
+    const period = pkg.product.subscriptionPeriod;
+    return period?.includes("W") || period?.includes("week") || false;
+};
+
+/**
+ * Find the first yearly package in an array of packages
+ */
+export const findYearlyPackage = (
+    packages: PurchasesPackage[]
+): PurchasesPackage | undefined => {
+    return packages.find(isYearlyPackage);
+};