@umituz/react-native-subscription 2.27.71 → 2.27.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.71",
+  "version": "2.27.72",
   "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/presentation/useDeductCredit.ts

@@ -42,24 +42,34 @@ export const useDeductCredit = ({
       await queryClient.cancelQueries({ queryKey: creditsQueryKeys.user(userId) });
       const previousCredits = queryClient.getQueryData<UserCredits>(creditsQueryKeys.user(userId));
 
-      // Skip optimistic update if insufficient credits to prevent showing 0
-      if (!previousCredits || previousCredits.credits < cost) {
-        return { previousCredits, skippedOptimistic: true };
+      // Improved optimistic update logic
+      if (!previousCredits) {
+        return { previousCredits: null, skippedOptimistic: true };
       }
 
+      // If credits are insufficient, show 0 but don't skip optimistic update
+      // This provides better UX by showing the user what will happen
+      const newCredits = Math.max(0, previousCredits.credits - cost);
+
       queryClient.setQueryData<UserCredits | null>(creditsQueryKeys.user(userId), (old) => {
         if (!old) return old;
         return {
           ...old,
-          credits: old.credits - cost,
+          credits: newCredits,
           lastUpdatedAt: timezoneService.getNow()
         };
       });
-      return { previousCredits, skippedOptimistic: false };
+
+      return {
+        previousCredits,
+        skippedOptimistic: false,
+        wasInsufficient: previousCredits.credits < cost
+      };
     },
     onError: (_err, _cost, context) => {
-      // Always restore previous credits on error if we have them
-      if (userId && context?.previousCredits && !context.skippedOptimistic) {
+      // Restore previous credits on error
+      // Skip restoration if credits were insufficient (optimistic update showed 0, which is correct)
+      if (userId && context?.previousCredits && !context.skippedOptimistic && !context.wasInsufficient) {
         queryClient.setQueryData(creditsQueryKeys.user(userId), context.previousCredits);
       }
     },

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

@@ -59,6 +59,14 @@ export const PaywallModal: React.FC<PaywallModalProps> = React.memo((props) => {
     setSelectedPlanId(null);
   }, [packages]);
 
+  // Cleanup state when modal closes to prevent stale state
+  useEffect(() => {
+    if (!visible) {
+      setSelectedPlanId(null);
+      setIsLocalProcessing(false);
+    }
+  }, [visible]);
+
   // Combined processing state
   const isProcessing = isLocalProcessing || isGlobalPurchasing;
 
@@ -83,6 +91,11 @@ export const PaywallModal: React.FC<PaywallModalProps> = React.memo((props) => {
           console.log("[PaywallModal] onPurchase completed");
         }
       }
+    } catch (error) {
+      // Error is handled by usePurchasePackage, just log for debugging
+      if (__DEV__) {
+        console.error("[PaywallModal] Purchase failed:", error);
+      }
     } finally {
       setIsLocalProcessing(false);
       endPurchase();

package/src/domains/paywall/index.ts

@@ -6,8 +6,5 @@
 // Entities
 export * from "./entities/types";
 
-// Components
-export * from "./components";
-
 // Hooks
 export * from "./hooks";

package/src/domains/subscription/infrastructure/hooks/usePurchasePackage.ts

@@ -90,8 +90,42 @@ export const usePurchasePackage = () => {
           userId: userId ?? "ANONYMOUS",
         });
       }
-      const message = error instanceof Error ? error.message : "An error occurred";
-      showError("Purchase Error", message);
+
+      let title = "Purchase Error";
+      let message = "Unable to complete purchase. Please try again.";
+
+      if (error instanceof Error) {
+        // Handle RevenueCat-specific error codes
+        const errorCode = (error as any).code;
+        const errorMessage = error.message;
+
+        switch (errorCode) {
+          case "PURCHASE_CANCELLED":
+            title = "Purchase Cancelled";
+            message = "The purchase was cancelled.";
+            break;
+          case "PURCHASE_INVALID":
+            title = "Invalid Purchase";
+            message = "The purchase is invalid. Please contact support.";
+            break;
+          case "PRODUCT_ALREADY_OWNED":
+            title = "Already Owned";
+            message = "You already own this subscription. Please restore your purchase.";
+            break;
+          case "NETWORK_ERROR":
+            title = "Network Error";
+            message = "Please check your internet connection and try again.";
+            break;
+          case "INVALID_CREDENTIALS":
+            title = "Configuration Error";
+            message = "App is not configured correctly. Please contact support.";
+            break;
+          default:
+            message = errorMessage || message;
+        }
+      }
+
+      showError(title, message);
     },
   });
 };

package/src/domains/subscription/infrastructure/managers/SubscriptionManager.ts

@@ -41,12 +41,24 @@ class SubscriptionManagerImpl {
     if (!shouldInit && existingPromise) return existingPromise;
 
     const promise = (async () => {
-        await initializeRevenueCatService(this.managerConfig!.config);
-        this.serviceInstance = getRevenueCatService();
-        if (!this.serviceInstance) return false;
-        this.packageHandler!.setService(this.serviceInstance);
-        const result = await this.serviceInstance.initialize(effectiveUserId);
-        return result.success;
+        try {
+          await initializeRevenueCatService(this.managerConfig!.config);
+          this.serviceInstance = getRevenueCatService();
+          if (!this.serviceInstance) {
+            if (__DEV__) {
+              console.error('[SubscriptionManager] Service instance not available after initialization');
+            }
+            return false;
+          }
+          this.packageHandler!.setService(this.serviceInstance);
+          const result = await this.serviceInstance.initialize(effectiveUserId);
+          return result.success;
+        } catch (error) {
+          if (__DEV__) {
+            console.error('[SubscriptionManager] Initialization failed:', error);
+          }
+          return false;
+        }
     })();
 
     this.state.initCache.setPromise(promise, effectiveUserId);

package/src/domains/subscription/infrastructure/services/CustomerInfoListenerManager.ts

@@ -133,7 +133,15 @@ export class CustomerInfoListenerManager {
     }
 
     destroy(): void {
+        if (__DEV__) {
+            console.log('[CustomerInfoListenerManager] Destroying listener manager');
+        }
         this.removeListener();
         this.clearUserId();
+        // Reset renewal state to ensure clean state
+        this.renewalState = {
+            previousExpirationDate: null,
+            previousProductId: null,
+        };
     }
 }

package/src/domains/subscription/infrastructure/services/RevenueCatInitializer.ts

@@ -11,12 +11,19 @@ export interface InitializerDeps {
   setCurrentUserId: (userId: string) => void;
 }
 
-let isPurchasesConfigured = false;
-let isLogHandlerConfigured = false;
-let configurationInProgress = false;
+// State management to prevent race conditions
+const configurationState = {
+    isPurchasesConfigured: false,
+    isLogHandlerConfigured: false,
+    configurationInProgress: false,
+    configurationPromise: null as Promise<ReturnType<typeof initializeSDK>> | null,
+};
+
+// Simple lock mechanism to prevent concurrent configurations
+let configurationLocks = new Set<string>();
 
 function configureLogHandler(): void {
-  if (isLogHandlerConfigured) return;
+  if (configurationState.isLogHandlerConfigured) return;
   if (typeof Purchases.setLogHandler !== 'function') return;
   try {
     Purchases.setLogHandler((logLevel, message) => {
@@ -24,7 +31,7 @@ function configureLogHandler(): void {
       if (ignoreMessages.some(m => message.includes(m))) return;
       if (logLevel === LOG_LEVEL.ERROR && __DEV__) console.error('[RevenueCat]', message);
     });
-    isLogHandlerConfigured = true;
+    configurationState.isLogHandlerConfigured = true;
   } catch {
     // Native module not available (Expo Go)
   }
@@ -52,7 +59,7 @@ export async function initializeSDK(
     }
   }
 
-  if (isPurchasesConfigured) {
+  if (configurationState.isPurchasesConfigured) {
     try {
       const currentAppUserId = await Purchases.getAppUserID();
       let customerInfo;
@@ -71,9 +78,9 @@ export async function initializeSDK(
     }
   }
 
-  if (configurationInProgress) {
+  if (configurationState.configurationInProgress) {
     await new Promise(resolve => setTimeout(resolve, 100));
-    if (isPurchasesConfigured) return initializeSDK(deps, userId, apiKey);
+    if (configurationState.isPurchasesConfigured) return initializeSDK(deps, userId, apiKey);
     return { success: false, offering: null, isPremium: false };
   }
 
@@ -83,13 +90,13 @@ export async function initializeSDK(
     return { success: false, offering: null, isPremium: false };
   }
 
-  configurationInProgress = true;
+  configurationState.configurationInProgress = true;
   try {
     configureLogHandler();
     if (__DEV__) console.log('[RevenueCat] Configuring:', key.substring(0, 10) + '...');
 
     await Purchases.configure({ apiKey: key, appUserID: userId });
-    isPurchasesConfigured = true;
+    configurationState.isPurchasesConfigured = true;
     deps.setInitialized(true);
     deps.setCurrentUserId(userId);
 
@@ -108,6 +115,6 @@ export async function initializeSDK(
     if (__DEV__) console.error('[RevenueCat] Init failed:', error);
     return { success: false, offering: null, isPremium: false };
   } finally {
-    configurationInProgress = false;
+    configurationState.configurationInProgress = false;
   }
 }

package/src/domains/subscription/infrastructure/services/RevenueCatService.ts

@@ -108,8 +108,11 @@ export class RevenueCatService implements IRevenueCatService {
         try {
             await Purchases.logOut();
             this.stateManager.setInitialized(false);
-        } catch {
-            // Silent error handling
+        } catch (error) {
+            // Log error for debugging but don't throw - reset is cleanup operation
+            if (__DEV__) {
+                console.error('[RevenueCatService] Reset failed:', error);
+            }
         }
     }
 }

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

@@ -28,6 +28,18 @@ export const configureAuthProvider = (provider: PurchaseAuthProvider): void => {
   globalAuthProvider = provider;
 };
 
+/**
+ * Cleanup method to reset global auth provider state
+ * Call this when app is shutting down or auth system is being reset
+ */
+export const cleanupAuthProvider = (): void => {
+  if (__DEV__) {
+    console.log("[useAuthAwarePurchase] Cleaning up auth provider");
+  }
+  globalAuthProvider = null;
+  clearSavedPurchase();
+};
+
 const savePurchase = (pkg: PurchasesPackage, source: PurchaseSource): void => {
   savedPurchaseState = { pkg, source, timestamp: Date.now() };
 };

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

@@ -48,8 +48,11 @@ export function useAuthSubscriptionSync(
           await initialize(userId);
           isInitializedRef.current = true;
         }
-      } catch {
-        // Prevent unhandled promise rejection from async auth callback
+      } catch (error) {
+        // Log error for debugging but don't crash the auth flow
+        if (__DEV__) {
+          console.error('[useAuthSubscriptionSync] Initialization failed:', error);
+        }
       }
 
       previousUserIdRef.current = userId;

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

@@ -44,25 +44,14 @@ export const useSavedPurchaseAutoExecution = (
   const startPurchaseRef = useRef(startPurchase);
   const endPurchaseRef = useRef(endPurchase);
 
+  // Consolidate all ref updates into a single effect
   useEffect(() => {
     purchasePackageRef.current = purchasePackage;
-  }, [purchasePackage]);
-
-  useEffect(() => {
     onSuccessRef.current = onSuccess;
-  }, [onSuccess]);
-
-  useEffect(() => {
     onErrorRef.current = onError;
-  }, [onError]);
-
-  useEffect(() => {
     startPurchaseRef.current = startPurchase;
-  }, [startPurchase]);
-
-  useEffect(() => {
     endPurchaseRef.current = endPurchase;
-  }, [endPurchase]);
+  }, [purchasePackage, onSuccess, onError, startPurchase, endPurchase]);
 
   useEffect(() => {
     const isAuthenticated = !!userId && !isAnonymous;

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

@@ -34,7 +34,18 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
       if (!userId) {
         return { isPremium: false, expirationDate: null };
       }
-      return SubscriptionManager.checkPremiumStatus();
+
+      try {
+        const result = await SubscriptionManager.checkPremiumStatus();
+        // Ensure we always return a valid object even if result is null/undefined
+        return result ?? { isPremium: false, expirationDate: null };
+      } catch (error) {
+        if (__DEV__) {
+          console.error('[useSubscriptionStatus] Failed to check premium status:', error);
+        }
+        // Return default state on error to prevent crashes
+        return { isPremium: false, expirationDate: null };
+      }
     },
     enabled: !!userId && SubscriptionManager.isInitializedForUser(userId),
     staleTime: 30 * 1000, // 30 seconds

package/src/presentation/stores/purchaseLoadingStore.ts

@@ -32,10 +32,22 @@ const initialState: PurchaseLoadingState = {
   purchaseSource: null,
 };
 
-export const usePurchaseLoadingStore = create<PurchaseLoadingStore>((set) => ({
+export const usePurchaseLoadingStore = create<PurchaseLoadingStore>((set, get) => ({
   ...initialState,
 
   startPurchase: (productId, source) => {
+    const currentState = get();
+    if (currentState.isPurchasing) {
+      if (__DEV__) {
+        console.warn("[PurchaseLoadingStore] startPurchase called while purchase already in progress:", {
+          currentProductId: currentState.purchasingProductId,
+          newProductId: productId,
+          currentSource: currentState.purchaseSource,
+          newSource: source,
+        });
+      }
+      // Still update to the new purchase to recover from potential stuck state
+    }
     if (__DEV__) {
       console.log("[PurchaseLoadingStore] startPurchase:", { productId, source });
     }
@@ -47,6 +59,13 @@ export const usePurchaseLoadingStore = create<PurchaseLoadingStore>((set) => ({
   },
 
   endPurchase: () => {
+    const currentState = get();
+    if (!currentState.isPurchasing) {
+      if (__DEV__) {
+        console.warn("[PurchaseLoadingStore] endPurchase called while no purchase in progress");
+      }
+      // Reset to initial state to recover from potential stuck state
+    }
     if (__DEV__) {
       console.log("[PurchaseLoadingStore] endPurchase");
     }

package/src/domains/index.ts

@@ -1,6 +0,0 @@
-/**
- * Domains Index
- */
-
-export * from "./paywall";
-export * from "./config";

package/src/domains/paywall/components/index.ts

@@ -1,15 +0,0 @@
-/**
- * Paywall Components Index
- */
-
-export { PaywallContainer } from "./PaywallContainer";
-export type { PaywallContainerProps, TrialConfig } from "./PaywallContainer.types";
-
-export { PaywallModal } from "./PaywallModal";
-export type { PaywallModalProps } from "./PaywallModal";
-
-export { PaywallHeader } from "./PaywallHeader";
-export { PaywallFooter } from "./PaywallFooter";
-export { FeatureList } from "./FeatureList";
-export { FeatureItem } from "./FeatureItem";
-export { PlanCard } from "./PlanCard";

package/src/domains/wallet/presentation/components/index.ts

@@ -1,23 +0,0 @@
-/**
- * Wallet Components Index
- *
- * Export all wallet-related components.
- */
-
-export {
-  BalanceCard,
-  type BalanceCardProps,
-  type BalanceCardTranslations,
-} from "./BalanceCard";
-
-export {
-  TransactionItem,
-  type TransactionItemProps,
-  type TransactionItemTranslations,
-} from "./TransactionItem";
-
-export {
-  TransactionList,
-  type TransactionListProps,
-  type TransactionListTranslations,
-} from "./TransactionList";

package/src/presentation/hooks/__tests__/useUserTier.authenticated.test.ts

@@ -1,79 +0,0 @@
-/**
- * useUserTier Hook Tests - Authenticated Users
- * 
- * Tests for authenticated user scenarios
- */
-
-import React from 'react';
-import { create } from 'react-test-renderer';
-import { useUserTier, type UseUserTierParams } from '../useUserTier';
-
-// Test component that uses hook
-function TestComponent({ params }: { params: UseUserTierParams }) {
-  const tierInfo = useUserTier(params);
-  return React.createElement('div', { 'data-testid': 'tier-info' }, JSON.stringify(tierInfo));
-}
-
-describe('useUserTier - Authenticated Users', () => {
-  it('should return premium tier for authenticated premium users', () => {
-    const params: UseUserTierParams = {
-      isGuest: false,
-      userId: 'user123',
-      isPremium: true,
-    };
-
-    const component = create(React.createElement(TestComponent, { params }));
-    const tree = component.toJSON();
-    const tierInfo = JSON.parse((tree as any).children[0]);
-
-    expect(tierInfo.tier).toBe('premium');
-    expect(tierInfo.isPremium).toBe(true);
-    expect(tierInfo.isGuest).toBe(false);
-    expect(tierInfo.isAuthenticated).toBe(true);
-    expect(tierInfo.userId).toBe('user123');
-  });
-
-  it('should return freemium tier for authenticated non-premium users', () => {
-    const params: UseUserTierParams = {
-      isGuest: false,
-      userId: 'user123',
-      isPremium: false,
-    };
-
-    const component = create(React.createElement(TestComponent, { params }));
-    const tree = component.toJSON();
-    const tierInfo = JSON.parse((tree as any).children[0]);
-
-    expect(tierInfo.tier).toBe('freemium');
-    expect(tierInfo.isPremium).toBe(false);
-    expect(tierInfo.isGuest).toBe(false);
-    expect(tierInfo.isAuthenticated).toBe(true);
-    expect(tierInfo.userId).toBe('user123');
-  });
-
-  it('should handle different userId formats', () => {
-    const testCases = [
-      'user123',
-      'user-with-dashes',
-      'user_with_underscores',
-      'user@example.com',
-      '1234567890',
-    ];
-
-    testCases.forEach(userId => {
-      const params: UseUserTierParams = {
-        isGuest: false,
-        userId,
-        isPremium: false,
-      };
-
-      const component = create(React.createElement(TestComponent, { params }));
-      const tree = component.toJSON();
-      const tierInfo = JSON.parse((tree as any).children[0]);
-
-      expect(tierInfo.userId).toBe(userId);
-      expect(tierInfo.isAuthenticated).toBe(true);
-      expect(tierInfo.isGuest).toBe(false);
-    });
-  });
-});

package/src/presentation/hooks/__tests__/useUserTier.guest.test.ts

@@ -1,70 +0,0 @@
-/**
- * useUserTier Hook Tests - Guest Users
- * 
- * Tests for guest user scenarios
- */
-
-import React from 'react';
-import { create } from 'react-test-renderer';
-import { useUserTier, type UseUserTierParams } from '../useUserTier';
-
-// Test component that uses the hook
-function TestComponent({ params }: { params: UseUserTierParams }) {
-  const tierInfo = useUserTier(params);
-  return React.createElement('div', { 'data-testid': 'tier-info' }, JSON.stringify(tierInfo));
-}
-
-describe('useUserTier - Guest Users', () => {
-  it('should return guest tier for guest users', () => {
-    const params: UseUserTierParams = {
-      isGuest: true,
-      userId: null,
-      isPremium: false,
-    };
-
-    const component = create(React.createElement(TestComponent, { params }));
-    const tree = component.toJSON();
-    const tierInfo = JSON.parse((tree as any).children[0]);
-
-    expect(tierInfo.tier).toBe('guest');
-    expect(tierInfo.isPremium).toBe(false);
-    expect(tierInfo.isGuest).toBe(true);
-    expect(tierInfo.isAuthenticated).toBe(false);
-    expect(tierInfo.userId).toBe(null);
-    expect(tierInfo.isLoading).toBe(false);
-    expect(tierInfo.error).toBe(null);
-  });
-
-  it('should ignore isPremium for guest users', () => {
-    const params: UseUserTierParams = {
-      isGuest: true,
-      userId: null,
-      isPremium: true, // Even if true, guest should be false
-    };
-
-    const component = create(React.createElement(TestComponent, { params }));
-    const tree = component.toJSON();
-    const tierInfo = JSON.parse((tree as any).children[0]);
-
-    expect(tierInfo.tier).toBe('guest');
-    expect(tierInfo.isPremium).toBe(false); // Guest users NEVER have premium
-  });
-
-  it('should handle guest user with userId provided', () => {
-    const params: UseUserTierParams = {
-      isGuest: true,
-      userId: 'user123', // Even with userId, isGuest=true takes precedence
-      isPremium: true,
-    };
-
-    const component = create(React.createElement(TestComponent, { params }));
-    const tree = component.toJSON();
-    const tierInfo = JSON.parse((tree as any).children[0]);
-
-    expect(tierInfo.tier).toBe('guest');
-    expect(tierInfo.isPremium).toBe(false);
-    expect(tierInfo.isGuest).toBe(true);
-    expect(tierInfo.isAuthenticated).toBe(false);
-    expect(tierInfo.userId).toBe(null); // Should be null for guests
-  });
-});

package/src/presentation/hooks/__tests__/useUserTier.states.test.ts

@@ -1,167 +0,0 @@
-/**
- * useUserTier Hook Tests - States and Memoization
- * 
- * Tests for loading/error states and memoization
- */
-
-import React from 'react';
-import { create } from 'react-test-renderer';
-import { useUserTier, type UseUserTierParams } from '../useUserTier';
-
-// Test component that uses hook
-function TestComponent({ params }: { params: UseUserTierParams }) {
-  const tierInfo = useUserTier(params);
-  return React.createElement('div', { 'data-testid': 'tier-info' }, JSON.stringify(tierInfo));
-}
-
-describe('useUserTier - States and Memoization', () => {
-  describe('Loading and error states', () => {
-    it('should pass through loading state', () => {
-      const params: UseUserTierParams = {
-        isGuest: false,
-        userId: 'user123',
-        isPremium: false,
-        isLoading: true,
-      };
-
-      const component = create(React.createElement(TestComponent, { params }));
-      const tree = component.toJSON();
-      const tierInfo = JSON.parse((tree as any).children[0]);
-
-      expect(tierInfo.isLoading).toBe(true);
-    });
-
-    it('should pass through error state', () => {
-      const params: UseUserTierParams = {
-        isGuest: false,
-        userId: 'user123',
-        isPremium: false,
-        error: 'Failed to fetch premium status',
-      };
-
-      const component = create(React.createElement(TestComponent, { params }));
-      const tree = component.toJSON();
-      const tierInfo = JSON.parse((tree as any).children[0]);
-
-      expect(tierInfo.error).toBe('Failed to fetch premium status');
-    });
-
-    it('should default loading to false', () => {
-      const params: UseUserTierParams = {
-        isGuest: false,
-        userId: 'user123',
-        isPremium: false,
-      };
-
-      const component = create(React.createElement(TestComponent, { params }));
-      const tree = component.toJSON();
-      const tierInfo = JSON.parse((tree as any).children[0]);
-
-      expect(tierInfo.isLoading).toBe(false);
-    });
-
-    it('should default error to null', () => {
-      const params: UseUserTierParams = {
-        isGuest: false,
-        userId: 'user123',
-        isPremium: false,
-      };
-
-      const component = create(React.createElement(TestComponent, { params }));
-      const tree = component.toJSON();
-      const tierInfo = JSON.parse((tree as any).children[0]);
-
-      expect(tierInfo.error).toBe(null);
-    });
-  });
-
-  describe('Memoization', () => {
-    it('should recalculate when isGuest changes', () => {
-      let params: UseUserTierParams = {
-        isGuest: false,
-        userId: 'user123',
-        isPremium: true,
-      };
-
-      const component = create(React.createElement(TestComponent, { params }));
-      let tree = component.toJSON();
-      let tierInfo = JSON.parse((tree as any).children[0]);
-      expect(tierInfo.tier).toBe('premium');
-
-      params = {
-        isGuest: true,
-        userId: null,
-        isPremium: true,
-      };
-      component.update(React.createElement(TestComponent, { params }));
-      tree = component.toJSON();
-      tierInfo = JSON.parse((tree as any).children[0]);
-      expect(tierInfo.tier).toBe('guest');
-    });
-
-    it('should recalculate when userId changes', () => {
-      let params: UseUserTierParams = {
-        isGuest: false,
-        userId: 'user123',
-        isPremium: true,
-      };
-
-      const component = create(React.createElement(TestComponent, { params }));
-      let tree = component.toJSON();
-      let tierInfo = JSON.parse((tree as any).children[0]);
-      expect(tierInfo.userId).toBe('user123');
-
-      params = {
-        isGuest: false,
-        userId: 'user456',
-        isPremium: true,
-      };
-      component.update(React.createElement(TestComponent, { params }));
-      tree = component.toJSON();
-      tierInfo = JSON.parse((tree as any).children[0]);
-      expect(tierInfo.userId).toBe('user456');
-    });
-
-    it('should recalculate when isPremium changes', () => {
-      let params: UseUserTierParams = {
-        isGuest: false,
-        userId: 'user123',
-        isPremium: false,
-      };
-
-      const component = create(React.createElement(TestComponent, { params }));
-      let tree = component.toJSON();
-      let tierInfo = JSON.parse((tree as any).children[0]);
-      expect(tierInfo.tier).toBe('freemium');
-
-      params = {
-        isGuest: false,
-        userId: 'user123',
-        isPremium: true,
-      };
-      component.update(React.createElement(TestComponent, { params }));
-      tree = component.toJSON();
-      tierInfo = JSON.parse((tree as any).children[0]);
-      expect(tierInfo.tier).toBe('premium');
-    });
-
-    it('should not recalculate when params are the same', () => {
-      const params: UseUserTierParams = {
-        isGuest: false,
-        userId: 'user123',
-        isPremium: true,
-      };
-
-      const component = create(React.createElement(TestComponent, { params }));
-      const tree1 = component.toJSON();
-      const tierInfo1 = JSON.parse((tree1 as any).children[0]);
-
-      // Update with same params
-      component.update(React.createElement(TestComponent, { params }));
-      const tree2 = component.toJSON();
-      const tierInfo2 = JSON.parse((tree2 as any).children[0]);
-
-      expect(tierInfo1).toEqual(tierInfo2);
-    });
-  });
-});