@umituz/react-native-subscription 2.27.112 → 2.27.114

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

@@ -2,9 +2,10 @@
  * Paywall Modal
  */
 
-import React, { useState, useCallback, useEffect } from "react";
-import { View, ScrollView, TouchableOpacity, Linking, type ImageSourcePropType } from "react-native";
-import { BaseModal, useAppDesignTokens, AtomicText, AtomicIcon, AtomicSpinner } from "@umituz/react-native-design-system";
+import React, { useCallback, useEffect } from "react";
+import { View, TouchableOpacity, Linking, type ImageSourcePropType } from "react-native";
+import { BaseModal, useAppDesignTokens, AtomicText, AtomicIcon, AtomicSpinner, useSafeAreaInsets } from "@umituz/react-native-design-system";
+import { ScreenLayout } from "../../../shared/presentation";
 import { Image } from "expo-image";
 import type { PurchasesPackage } from "react-native-purchases";
 import { PlanCard } from "./PlanCard";
@@ -12,7 +13,7 @@ import type { SubscriptionFeature, PaywallTranslations, PaywallLegalUrls } from
 import { paywallModalStyles as styles } from "./PaywallModal.styles";
 import { PaywallFeatures } from "./PaywallFeatures";
 import { PaywallFooter } from "./PaywallFooter";
-import { usePurchaseLoadingStore, selectIsPurchasing } from "../../subscription/presentation/stores";
+import { usePaywallActions } from "../hooks/usePaywallActions";
 
 /** Trial eligibility info per product */
 export interface TrialEligibilityInfo {
@@ -47,60 +48,28 @@ export interface PaywallModalProps {
 export const PaywallModal: React.FC<PaywallModalProps> = React.memo((props) => {
   const { visible, onClose, translations, packages = [], features = [], isLoading = false, legalUrls = {}, bestValueIdentifier, creditAmounts, creditsLabel, heroImage, onPurchase, onRestore, trialEligibility = {}, trialSubtitleText } = props;
   const tokens = useAppDesignTokens();
-  const [selectedPlanId, setSelectedPlanId] = useState<string | null>(null);
-  const [isLocalProcessing, setIsLocalProcessing] = useState(false);
-
-  // Global purchase loading state (for auto-execution after auth)
-  const isGlobalPurchasing = usePurchaseLoadingStore(selectIsPurchasing);
-  const { startPurchase, endPurchase } = usePurchaseLoadingStore();
+  const insets = useSafeAreaInsets();
+  
+  const {
+    selectedPlanId,
+    setSelectedPlanId,
+    isProcessing,
+    handlePurchase,
+    handleRestore,
+    resetState,
+  } = usePaywallActions({ packages, onPurchase, onRestore });
 
   // Reset selected plan when packages change
   useEffect(() => {
     setSelectedPlanId(null);
-  }, [packages]);
+  }, [packages, setSelectedPlanId]);
 
   // Cleanup state when modal closes to prevent stale state
   useEffect(() => {
     if (!visible) {
-      setSelectedPlanId(null);
-      setIsLocalProcessing(false);
-    }
-  }, [visible]);
-
-  // Combined processing state
-  const isProcessing = isLocalProcessing || isGlobalPurchasing;
-
-  const handlePurchase = useCallback(async () => {
-    if (!selectedPlanId || !onPurchase) return;
-
-    setIsLocalProcessing(true);
-    startPurchase(selectedPlanId, "manual");
-
-    try {
-      const pkg = packages.find((p) => p.product.identifier === selectedPlanId);
-      if (pkg) {
-        await onPurchase(pkg);
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[PaywallModal] Purchase failed:", error);
-      }
-    } finally {
-      setIsLocalProcessing(false);
-      endPurchase();
-    }
-  }, [selectedPlanId, packages, onPurchase, startPurchase, endPurchase]);
-
-  const handleRestore = useCallback(async () => {
-    if (!onRestore || isProcessing) return;
-
-    setIsLocalProcessing(true);
-    try {
-      await onRestore();
-    } finally {
-      setIsLocalProcessing(false);
+      resetState();
     }
-  }, [onRestore, isProcessing]);
+  }, [visible, resetState]);
 
   const handleLegalUrl = useCallback(async (url: string | undefined) => {
     if (!url) return;
@@ -110,11 +79,18 @@ export const PaywallModal: React.FC<PaywallModalProps> = React.memo((props) => {
   return (
     <BaseModal visible={visible} onClose={onClose} contentStyle={styles.modalContent}>
       <View style={[styles.container, { backgroundColor: tokens.colors.surface }]}>
-        <TouchableOpacity onPress={onClose} style={[styles.closeBtn, { backgroundColor: tokens.colors.surfaceSecondary }]} hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}>
+        <TouchableOpacity 
+          onPress={onClose} 
+          style={[
+            styles.closeBtn, 
+            { backgroundColor: tokens.colors.surfaceSecondary, top: Math.max(insets.top, 12) }
+          ]} 
+          hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
+        >
           <AtomicIcon name="close-outline" size="md" customColor={tokens.colors.textPrimary} />
         </TouchableOpacity>
 
-        <ScrollView showsVerticalScrollIndicator={false} contentContainerStyle={styles.scroll}>
+        <ScreenLayout scrollable={true} edges={["bottom"]} backgroundColor="transparent" contentContainerStyle={styles.scroll}>
           {heroImage && (
             <View style={styles.heroContainer}>
               <Image source={heroImage} style={styles.heroImage} contentFit="cover" transition={0} />
@@ -171,7 +147,7 @@ export const PaywallModal: React.FC<PaywallModalProps> = React.memo((props) => {
           </TouchableOpacity>
 
           <PaywallFooter translations={translations} legalUrls={legalUrls} isProcessing={isProcessing} onRestore={onRestore ? handleRestore : undefined} onLegalClick={handleLegalUrl} />
-        </ScrollView>
+        </ScreenLayout>
       </View>
     </BaseModal>
   );

package/src/domains/paywall/hooks/usePaywallActions.ts

@@ -1,55 +1,99 @@
-import { useCallback } from "react";
+/**
+ * usePaywallActions Hook
+ * Encapsulates purchase and restore flow for the paywall.
+ */
+import { useState, useCallback } from "react";
 import type { PurchasesPackage } from "react-native-purchases";
-import { useRestorePurchase } from "../../subscription/infrastructure/hooks/useRestorePurchase";
-import { useAuthAwarePurchase } from "../../subscription/presentation/useAuthAwarePurchase";
+import { usePurchaseLoadingStore } from "../../subscription/presentation/stores";
 import type { PurchaseSource } from "../../subscription/core/SubscriptionConstants";
 
-interface UsePaywallActionsProps {
+export interface UsePaywallActionsParams {
+  packages?: PurchasesPackage[];
+  onPurchase?: (pkg: PurchasesPackage) => Promise<void | boolean>;
+  onRestore?: () => Promise<void | boolean>;
   source?: PurchaseSource;
   onPurchaseSuccess?: () => void;
-  onPurchaseError?: (error: string) => void;
+  onPurchaseError?: (error: Error | string) => void;
   onAuthRequired?: () => void;
-  onClose: () => void;
+  onClose?: () => void;
 }
 
-export const usePaywallActions = ({
-  source,
+export function usePaywallActions({
+  packages = [],
+  onPurchase,
+  onRestore,
   onPurchaseSuccess,
   onPurchaseError,
-  onAuthRequired: _onAuthRequired,
+  onAuthRequired,
   onClose,
-}: UsePaywallActionsProps) => {
-  const { handlePurchase: authAwarePurchase } = useAuthAwarePurchase({ source });
-  const { mutateAsync: restorePurchases } = useRestorePurchase();
+}: UsePaywallActionsParams) {
+  const [selectedPlanId, setSelectedPlanId] = useState<string | null>(null);
+  const [isLocalProcessing, setIsLocalProcessing] = useState(false);
+
+  const { startPurchase, endPurchase } = usePurchaseLoadingStore();
+  const isGlobalPurchasing = usePurchaseLoadingStore((state) => state.isPurchasing);
+
+  const isProcessing = isLocalProcessing || isGlobalPurchasing;
+
+  const handlePurchase = useCallback(async () => {
+    // If no plan selected, use the first available one as fallback or return
+    const planId = selectedPlanId || (packages.length > 0 ? packages[0]?.product.identifier : null);
+    
+    if (!planId || !onPurchase || isProcessing) {
+        if (!planId && onAuthRequired) onAuthRequired();
+        return;
+    }
+
+    setIsLocalProcessing(true);
+    // Map PurchaseSource to store's expected "manual" | "auto-execution"
+    startPurchase(planId, "manual");
 
-  const handlePurchase = useCallback(async (pkg: PurchasesPackage) => {
     try {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[PaywallActions] Purchase started:", pkg.product.identifier);
+      const pkg = packages.find((p) => p.product.identifier === planId);
+      if (pkg) {
+        const success = await onPurchase(pkg);
+        if (success !== false) {
+          onPurchaseSuccess?.();
+          onClose?.(); // Close on success if provided
+        }
       }
-      const res = await authAwarePurchase(pkg, source);
-      if (res) {
-        onPurchaseSuccess?.();
-        onClose();
-      }
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      onPurchaseError?.(message);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      onPurchaseError?.(err);
+    } finally {
+      setIsLocalProcessing(false);
+      endPurchase();
     }
-  }, [authAwarePurchase, source, onClose, onPurchaseSuccess, onPurchaseError]);
+  }, [selectedPlanId, packages, onPurchase, isProcessing, startPurchase, endPurchase, onPurchaseSuccess, onPurchaseError, onAuthRequired, onClose]);
 
   const handleRestore = useCallback(async () => {
+    if (!onRestore || isProcessing) return;
+
+    setIsLocalProcessing(true);
     try {
-      const res = await restorePurchases();
-      if (res.success) {
+      const success = await onRestore();
+      if (success !== false) {
         onPurchaseSuccess?.();
-        onClose();
       }
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      onPurchaseError?.(message);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      onPurchaseError?.(err);
+    } finally {
+      setIsLocalProcessing(false);
     }
-  }, [restorePurchases, onClose, onPurchaseSuccess, onPurchaseError]);
+  }, [onRestore, isProcessing, onPurchaseSuccess, onPurchaseError]);
 
-  return { handlePurchase, handleRestore };
-};
+  const resetState = useCallback(() => {
+    setSelectedPlanId(null);
+    setIsLocalProcessing(false);
+  }, []);
+
+  return {
+    selectedPlanId,
+    setSelectedPlanId,
+    isProcessing,
+    handlePurchase,
+    handleRestore,
+    resetState,
+  };
+}

package/src/domains/subscription/application/SubscriptionInitializer.ts

@@ -7,7 +7,7 @@
  */
 
 import { Platform } from "react-native";
-import { configureCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryProvider";
+import { configureCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
 import { SubscriptionManager } from "../infrastructure/managers/SubscriptionManager";
 import { configureAuthProvider } from "../presentation/useAuthAwarePurchase";
 import { SubscriptionSyncService } from "./SubscriptionSyncService";

package/src/domains/subscription/application/SubscriptionSyncService.ts

@@ -1,7 +1,7 @@
 import type { CustomerInfo } from "react-native-purchases";
 import type { RevenueCatData } from "../core/RevenueCatData";
 import { type PeriodType, type PurchaseSource, PURCHASE_SOURCE, PURCHASE_TYPE } from "../core/SubscriptionConstants";
-import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryProvider";
+import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
 import { extractRevenueCatData } from "./SubscriptionSyncUtils";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 
@@ -15,24 +15,22 @@ export class SubscriptionSyncService {
   async handlePurchase(userId: string, productId: string, customerInfo: CustomerInfo, source?: PurchaseSource) {
     try {
       const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
-      const purchaseId = revenueCatData.originalTransactionId 
+      const purchaseId = revenueCatData.originalTransactionId
         ? `purchase_${revenueCatData.originalTransactionId}`
         : `purchase_${productId}_${Date.now()}`;
 
       await getCreditsRepository().initializeCredits(
-        userId, 
-        purchaseId, 
-        productId, 
-        source ?? PURCHASE_SOURCE.SETTINGS, // Default to settings if source unknown
+        userId,
+        purchaseId,
+        productId,
+        source ?? PURCHASE_SOURCE.SETTINGS,
         revenueCatData,
-        PURCHASE_TYPE.INITIAL // Default to INITIAL
+        PURCHASE_TYPE.INITIAL
       );
-      
-      // Notify listeners via Event Bus
+
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PURCHASE_COMPLETED, { userId, productId });
-    } catch (error) {
-      if (__DEV__) console.error('[SubscriptionSyncService] Credits init failed:', error);
+    } catch {
     }
   }
 
@@ -40,23 +38,22 @@ export class SubscriptionSyncService {
     try {
       const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
       revenueCatData.expirationDate = newExpirationDate || revenueCatData.expirationDate;
-      const purchaseId = revenueCatData.originalTransactionId 
+      const purchaseId = revenueCatData.originalTransactionId
         ? `renewal_${revenueCatData.originalTransactionId}_${newExpirationDate}`
         : `renewal_${productId}_${Date.now()}`;
 
       await getCreditsRepository().initializeCredits(
-        userId, 
-        purchaseId, 
-        productId, 
-        PURCHASE_SOURCE.RENEWAL, 
+        userId,
+        purchaseId,
+        productId,
+        PURCHASE_SOURCE.RENEWAL,
         revenueCatData,
         PURCHASE_TYPE.RENEWAL
       );
-      
+
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.RENEWAL_DETECTED, { userId, productId });
-    } catch (error) {
-      if (__DEV__) console.error('[SubscriptionSyncService] Renewal credits init failed:', error);
+    } catch {
     }
   }
 
@@ -123,8 +120,7 @@ export class SubscriptionSyncService {
       
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, { userId, isPremium });
-    } catch (error) {
-      if (__DEV__) console.error('[SubscriptionSyncService] Premium status sync failed:', error);
+    } catch {
     }
   }
 }

package/src/domains/subscription/core/RevenueCatError.ts

@@ -3,54 +3,63 @@
  * Domain-specific error types for RevenueCat operations
  */
 
-export class RevenueCatError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "RevenueCatError";
-  }
+import { BaseError } from "../../../shared/utils/BaseError";
+
+export class RevenueCatError extends BaseError {
+    constructor(message: string, code: string = 'REVENUE_CAT_ERROR', cause?: Error) {
+        super(message, code, cause);
+        this.name = "RevenueCatError";
+    }
 }
 
 export class RevenueCatInitializationError extends RevenueCatError {
-  constructor(message = "RevenueCat service is not initialized") {
-    super(message);
-    this.name = "RevenueCatInitializationError";
-  }
+    constructor(message = "RevenueCat service is not initialized", cause?: Error) {
+        super(message, 'REVENUE_CAT_NOT_INITIALIZED', cause);
+        this.name = "RevenueCatInitializationError";
+    }
 }
 
 export class RevenueCatConfigurationError extends RevenueCatError {
-  constructor(message = "RevenueCat configuration is invalid") {
-    super(message);
-    this.name = "RevenueCatConfigurationError";
-  }
+    constructor(message = "RevenueCat configuration is invalid", cause?: Error) {
+        super(message, 'REVENUE_CAT_CONFIGURATION_ERROR', cause);
+        this.name = "RevenueCatConfigurationError";
+    }
 }
 
 export class RevenueCatPurchaseError extends RevenueCatError {
-  public productId: string | undefined;
+    public readonly productId: string | undefined;
+
+    constructor(message: string, productId?: string, cause?: Error) {
+        super(message, 'REVENUE_CAT_PURCHASE_ERROR', cause);
+        this.name = "RevenueCatPurchaseError";
+        this.productId = productId;
+    }
 
-  constructor(message: string, productId?: string) {
-    super(message);
-    this.name = "RevenueCatPurchaseError";
-    this.productId = productId;
-  }
+    override toJSON() {
+        return {
+            ...super.toJSON(),
+            productId: this.productId,
+        };
+    }
 }
 
 export class RevenueCatRestoreError extends RevenueCatError {
-  constructor(message = "Failed to restore purchases") {
-    super(message);
-    this.name = "RevenueCatRestoreError";
-  }
+    constructor(message = "Failed to restore purchases", cause?: Error) {
+        super(message, 'REVENUE_CAT_RESTORE_ERROR', cause);
+        this.name = "RevenueCatRestoreError";
+    }
 }
 
 export class RevenueCatNetworkError extends RevenueCatError {
-  constructor(message = "Network error during RevenueCat operation") {
-    super(message);
-    this.name = "RevenueCatNetworkError";
-  }
+    constructor(message = "Network error during RevenueCat operation", cause?: Error) {
+        super(message, 'REVENUE_CAT_NETWORK_ERROR', cause);
+        this.name = "RevenueCatNetworkError";
+    }
 }
 
 export class RevenueCatExpoGoError extends RevenueCatError {
-  constructor(message = "RevenueCat is not available in Expo Go. Use a development build or test store.") {
-    super(message);
-    this.name = "RevenueCatExpoGoError";
-  }
+    constructor(message = "RevenueCat is not available in Expo Go. Use a development build or test store.", cause?: Error) {
+        super(message, 'REVENUE_CAT_EXPO_GO_ERROR', cause);
+        this.name = "RevenueCatExpoGoError";
+    }
 }

package/src/domains/subscription/infrastructure/handlers/PackageHandler.ts

@@ -44,7 +44,6 @@ export class PackageHandler {
 
       return packages;
     } catch (error) {
-      // Re-throw with more context
       throw new Error(
         `Failed to fetch subscription packages. ${
           error instanceof Error ? error.message : "Unknown error"

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

@@ -5,24 +5,16 @@
  */
 
 import { useState, useEffect, useCallback, useRef } from "react";
-import Purchases, {
-  type IntroEligibility,
-  INTRO_ELIGIBILITY_STATUS,
-} from "react-native-purchases";
-import { getRevenueCatService } from "../../infrastructure/services/RevenueCatService";
+import { getRevenueCatService } from "../services/RevenueCatService";
+import {
+  checkTrialEligibility,
+  createFallbackEligibilityMap,
+  hasAnyEligibleTrial,
+  type ProductTrialEligibility,
+  type TrialEligibilityMap,
+} from "../utils/trialEligibilityUtils";
 
-/** Trial eligibility info for a single product */
-export interface ProductTrialEligibility {
-  /** Product identifier */
-  productId: string;
-  /** Whether eligible for introductory offer (free trial) */
-  eligible: boolean;
-  /** Trial duration in days (if available from product) */
-  trialDurationDays?: number;
-}
-
-/** Map of product ID to eligibility */
-export type TrialEligibilityMap = Record<string, ProductTrialEligibility>;
+export type { ProductTrialEligibility, TrialEligibilityMap };
 
 export interface UseRevenueCatTrialEligibilityResult {
   /** Map of product IDs to their trial eligibility */
@@ -37,17 +29,6 @@ export interface UseRevenueCatTrialEligibilityResult {
   getProductEligibility: (productId: string) => ProductTrialEligibility | null;
 }
 
-/** Cache duration in milliseconds (5 minutes) */
-const CACHE_DURATION_MS = 5 * 60 * 1000;
-
-/** Cached eligibility result */
-interface CachedEligibility {
-  data: TrialEligibilityMap;
-  timestamp: number;
-}
-
-let eligibilityCache: CachedEligibility | null = null;
-
 /**
  * Hook to check trial eligibility via RevenueCat
  * Uses Apple's introductory offer eligibility system
@@ -56,6 +37,7 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
   const [eligibilityMap, setEligibilityMap] = useState<TrialEligibilityMap>({});
   const [isLoading, setIsLoading] = useState(false);
   const isMountedRef = useRef(true);
+  const currentRequestRef = useRef<number | null>(null);
 
   useEffect(() => {
     isMountedRef.current = true;
@@ -69,69 +51,29 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
       return;
     }
 
-    // Check cache validity
-    if (
-      eligibilityCache &&
-      Date.now() - eligibilityCache.timestamp < CACHE_DURATION_MS
-    ) {
-      const allCached = productIds.every(
-        (id) => eligibilityCache?.data[id] !== undefined
-      );
-      if (allCached && isMountedRef.current) {
-        setEligibilityMap(eligibilityCache.data);
-        return;
-      }
-    }
-
     const service = getRevenueCatService();
     if (!service || !service.isInitialized()) {
       return;
     }
 
+    const requestId = Date.now();
+    currentRequestRef.current = requestId;
     setIsLoading(true);
 
     try {
-      const eligibilities: Record<string, IntroEligibility> =
-        await Purchases.checkTrialOrIntroductoryPriceEligibility(productIds);
-
-      const newMap: TrialEligibilityMap = {};
+      const newMap = await checkTrialEligibility(productIds);
 
-      for (const productId of productIds) {
-        const eligibility = eligibilities[productId];
-        const isEligible =
-          eligibility?.status === INTRO_ELIGIBILITY_STATUS.INTRO_ELIGIBILITY_STATUS_ELIGIBLE;
-
-        newMap[productId] = {
-          productId,
-          eligible: isEligible,
-          trialDurationDays: 7, // Default to 7 days as configured in App Store Connect
-        };
-      }
-
-      // Update cache
-      eligibilityCache = {
-        data: { ...eligibilityCache?.data, ...newMap },
-        timestamp: Date.now(),
-      };
-
-      if (isMountedRef.current) {
+      if (isMountedRef.current && currentRequestRef.current === requestId) {
         setEligibilityMap((prev) => ({ ...prev, ...newMap }));
       }
     } catch {
-      // On error, default to eligible (better UX)
-      const fallbackMap: TrialEligibilityMap = {};
-      for (const productId of productIds) {
-        fallbackMap[productId] = {
-          productId,
-          eligible: true,
-          trialDurationDays: 7,
-        };
-      }
-      if (isMountedRef.current) {
+      const fallbackMap = createFallbackEligibilityMap(productIds);
+
+      if (isMountedRef.current && currentRequestRef.current === requestId) {
         setEligibilityMap((prev) => ({ ...prev, ...fallbackMap }));
       }
     } finally {
-      if (isMountedRef.current) {
+      if (isMountedRef.current && currentRequestRef.current === requestId) {
         setIsLoading(false);
       }
     }
@@ -144,9 +86,7 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
     [eligibilityMap]
   );
 
-  const hasEligibleTrial = Object.values(eligibilityMap).some(
-    (e) => e.eligible
-  );
+  const hasEligibleTrial = hasAnyEligibleTrial(eligibilityMap);
 
   return {
     eligibilityMap,
@@ -157,9 +97,3 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
   };
 }
 
-/**
- * Clear eligibility cache (useful for testing)
- */
-export function clearTrialEligibilityCache(): void {
-  eligibilityCache = null;
-}