@umituz/react-native-subscription 2.27.30 → 2.27.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.30",
+  "version": "2.27.32",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -60,7 +60,6 @@
     "@umituz/react-native-auth": "^3.6.14",
     "@umituz/react-native-design-system": "^2.9.35",
     "@umituz/react-native-firebase": "*",
-    "@umituz/react-native-localization": "^3.6.0",
     "eslint": "^9.39.2",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.0.1",
@@ -85,9 +84,7 @@
     "expo-video": "~3.0.15",
     "expo-web-browser": "~15.0.10",
     "firebase": "^11.0.0",
-    "i18next": "^25.7.3",
     "react": "19.1.0",
-    "react-i18next": "^16.5.1",
     "react-native": "0.81.5",
     "react-native-gesture-handler": "^2.30.0",
     "react-native-purchases": "^7.0.0",

package/src/presentation/components/feedback/PaywallFeedbackModal.tsx

@@ -1,13 +1,6 @@
-/**
- * Paywall Feedback Modal
- * Collects user feedback when declining paywall
- */
-
 import React, { useMemo } from "react";
 import { View, TouchableOpacity, TextInput } from "react-native";
-import { AtomicText, BaseModal } from "@umituz/react-native-design-system";
-import { useAppDesignTokens } from "@umituz/react-native-design-system";
-import { useLocalization } from "@umituz/react-native-localization";
+import { AtomicText, BaseModal, useAppDesignTokens } from "@umituz/react-native-design-system";
 import { usePaywallFeedback } from "../../hooks/feedback/usePaywallFeedback";
 import { createPaywallFeedbackStyles } from "./paywallFeedbackStyles";
 
@@ -19,26 +12,33 @@ const FEEDBACK_OPTION_IDS = [
     "other",
 ] as const;
 
+export interface PaywallFeedbackTranslations {
+    title: string;
+    subtitle: string;
+    submit: string;
+    otherPlaceholder: string;
+    reasons: {
+        too_expensive: string;
+        no_need: string;
+        trying_out: string;
+        technical_issues: string;
+        other: string;
+    };
+}
+
 export interface PaywallFeedbackModalProps {
+    translations: PaywallFeedbackTranslations;
     visible: boolean;
     onClose: () => void;
     onSubmit: (reason: string) => void;
-    title?: string;
-    subtitle?: string;
-    submitText?: string;
-    otherPlaceholder?: string;
 }
 
 export const PaywallFeedbackModal: React.FC<PaywallFeedbackModalProps> = React.memo(({
+    translations,
     visible,
     onClose,
     onSubmit,
-    title,
-    subtitle,
-    submitText,
-    otherPlaceholder,
 }) => {
-    const { t } = useLocalization();
     const tokens = useAppDesignTokens();
 
     const {
@@ -47,7 +47,7 @@ export const PaywallFeedbackModal: React.FC<PaywallFeedbackModalProps> = React.m
         setOtherText,
         selectReason,
         handleSubmit,
-        handleSkip, // BaseModal's onClose will handle skipping
+        handleSkip,
         canSubmit,
     } = usePaywallFeedback({ onSubmit, onClose });
 
@@ -56,18 +56,12 @@ export const PaywallFeedbackModal: React.FC<PaywallFeedbackModalProps> = React.m
         [tokens, canSubmit],
     );
 
-    const displayTitle = title || t("paywall.feedback.title");
-    const displaySubtitle = subtitle || t("paywall.feedback.subtitle");
-    const displaySubmitText = submitText || t("paywall.feedback.submit");
-    const displayOtherPlaceholder = otherPlaceholder || t("paywall.feedback.otherPlaceholder");
-
-    // BaseModal from design system handles animations, safe areas, keyboard avoiding, and overlay backdrop
     return (
         <BaseModal
             visible={visible}
             onClose={handleSkip}
-            title={displayTitle}
-            subtitle={displaySubtitle}
+            title={translations.title}
+            subtitle={translations.subtitle}
         >
             <View style={{ paddingHorizontal: tokens.spacing.md, paddingBottom: tokens.spacing.lg }}>
                 <View style={[styles.optionsContainer, { backgroundColor: 'transparent', padding: 0 }]}>
@@ -75,7 +69,7 @@ export const PaywallFeedbackModal: React.FC<PaywallFeedbackModalProps> = React.m
                         const isSelected = selectedReason === optionId;
                         const isOther = optionId === "other";
                         const showInput = isSelected && isOther;
-                        const displayText = t(`paywall.feedback.reasons.${optionId}`);
+                        const displayText = translations.reasons[optionId];
                         
                         // Dynamic styles for the container
                         const containerStyle = {
@@ -135,7 +129,7 @@ export const PaywallFeedbackModal: React.FC<PaywallFeedbackModalProps> = React.m
                                                     padding: tokens.spacing.sm,
                                                 }
                                             ]}
-                                            placeholder={displayOtherPlaceholder}
+                                            placeholder={translations.otherPlaceholder}
                                             placeholderTextColor={tokens.colors.textTertiary}
                                             multiline
                                             maxLength={200}
@@ -157,7 +151,7 @@ export const PaywallFeedbackModal: React.FC<PaywallFeedbackModalProps> = React.m
                     activeOpacity={0.8}
                 >
                     <AtomicText type="labelLarge" style={styles.submitText}>
-                        {displaySubmitText}
+                        {translations.submit}
                     </AtomicText>
                 </TouchableOpacity>
             </View>

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

@@ -64,9 +64,11 @@ class SubscriptionManagerImpl {
 
     const effectiveUserId = userId || (await this.userIdProvider.getOrCreateAnonymousUserId());
 
-    if (!this.initCache.shouldReinitialize(effectiveUserId)) {
-      const existingPromise = this.initCache.getExistingPromise();
-      if (existingPromise) return existingPromise;
+    // Atomic check-and-acquire to prevent race conditions
+    const { shouldInit, existingPromise } = this.initCache.tryAcquireInitialization(effectiveUserId);
+
+    if (!shouldInit && existingPromise) {
+      return existingPromise;
     }
 
     const promise = this.performInitialization(effectiveUserId);

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

@@ -20,6 +20,8 @@ export interface InitializerDeps {
 
 let isPurchasesConfigured = false;
 let isLogHandlerConfigured = false;
+// Mutex to prevent concurrent configuration
+let configurationInProgress = false;
 
 function configureLogHandler(): void {
     if (isLogHandlerConfigured) return;
@@ -97,12 +99,26 @@ export async function initializeSDK(
     }
 
     // Case 3: First time configuration
+    // Check mutex to prevent double configuration
+    if (configurationInProgress) {
+        // Wait a bit and retry - another thread is configuring
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // After waiting, isPurchasesConfigured should be true
+        if (isPurchasesConfigured) {
+            return initializeSDK(deps, userId, apiKey);
+        }
+        return { success: false, offering: null, hasPremium: false };
+    }
+
     const key = apiKey || resolveApiKey(deps.config);
 
     if (!key) {
         return { success: false, offering: null, hasPremium: false };
     }
 
+    // Acquire mutex
+    configurationInProgress = true;
+
     try {
         configureLogHandler();
 
@@ -123,5 +139,8 @@ export async function initializeSDK(
     } catch (error) {
         getErrorMessage(error, "RevenueCat init failed");
         return { success: false, offering: null, hasPremium: false };
+    } finally {
+        // Release mutex
+        configurationInProgress = false;
     }
 }

package/src/revenuecat/infrastructure/utils/InitializationCache.ts

@@ -1,12 +1,43 @@
 /**
  * Initialization Cache
  * Manages promise caching and user state for initialization
+ * Thread-safe: Uses mutex pattern to prevent race conditions
  */
 
 export class InitializationCache {
     private initPromise: Promise<boolean> | null = null;
     private currentUserId: string | null = null;
+    // Mutex to prevent race condition during initialization
+    private initializationInProgress = false;
+    // Track which userId the promise is for (separate from currentUserId which is set after completion)
+    private promiseUserId: string | null = null;
 
+    /**
+     * Atomically check if reinitialization is needed AND reserve the slot
+     * Returns: { shouldInit: boolean, existingPromise: Promise | null }
+     */
+    tryAcquireInitialization(userId: string): { shouldInit: boolean; existingPromise: Promise<boolean> | null } {
+        // If initialization is in progress for the same user, return existing promise
+        if (this.initializationInProgress && this.promiseUserId === userId && this.initPromise) {
+            return { shouldInit: false, existingPromise: this.initPromise };
+        }
+
+        // If already initialized for this user and promise resolved successfully, return it
+        if (this.initPromise && this.currentUserId === userId && !this.initializationInProgress) {
+            return { shouldInit: false, existingPromise: this.initPromise };
+        }
+
+        // Different user or no initialization - need to reinitialize
+        // Atomically set the flag
+        this.initializationInProgress = true;
+        this.promiseUserId = userId;
+
+        return { shouldInit: true, existingPromise: null };
+    }
+
+    /**
+     * @deprecated Use tryAcquireInitialization instead for atomic operations
+     */
     shouldReinitialize(userId: string): boolean {
         if (!this.initPromise) {
             return true;
@@ -19,13 +50,38 @@ export class InitializationCache {
         return false;
     }
 
+    /**
+     * @deprecated Use tryAcquireInitialization instead for atomic operations
+     */
     getExistingPromise(): Promise<boolean> | null {
         return this.initPromise;
     }
 
     setPromise(promise: Promise<boolean>, userId: string): void {
         this.initPromise = promise;
-        this.currentUserId = userId;
+        this.promiseUserId = userId;
+
+        // Chain to mark completion and set currentUserId only on success
+        promise
+            .then((result) => {
+                if (result && this.promiseUserId === userId) {
+                    this.currentUserId = userId;
+                }
+                return result;
+            })
+            .catch(() => {
+                // On failure, clear the promise so retry is possible
+                if (this.promiseUserId === userId) {
+                    this.initPromise = null;
+                    this.promiseUserId = null;
+                }
+            })
+            .finally(() => {
+                // Always release the mutex
+                if (this.promiseUserId === userId) {
+                    this.initializationInProgress = false;
+                }
+            });
     }
 
     getCurrentUserId(): string | null {
@@ -35,5 +91,7 @@ export class InitializationCache {
     reset(): void {
         this.initPromise = null;
         this.currentUserId = null;
+        this.initializationInProgress = false;
+        this.promiseUserId = null;
     }
 }