@umituz/react-native-subscription 2.14.83 → 2.14.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.14.83",
+  "version": "2.14.85",
   "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/wallet/domain/errors/WalletError.ts

@@ -5,6 +5,8 @@
  * Follows the same pattern as SubscriptionError.
  */
 
+import { WALLET_ERROR_MESSAGES } from "./WalletErrorMessages";
+
 export type WalletErrorCategory =
   | "PAYMENT"
   | "VALIDATION"
@@ -39,110 +41,100 @@ export abstract class WalletError extends Error {
 export class PaymentValidationError extends WalletError {
   readonly code = "PAYMENT_VALIDATION_ERROR";
   readonly category = "PAYMENT" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.PAYMENT_VALIDATION_FAILED;
 
   constructor(message: string, cause?: Error) {
     super(message, cause);
-    this.userMessage = "Payment validation failed. Please try again.";
   }
 }
 
 export class PaymentProviderError extends WalletError {
   readonly code = "PAYMENT_PROVIDER_ERROR";
   readonly category = "PAYMENT" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.PAYMENT_PROVIDER_ERROR;
 
   constructor(message: string, cause?: Error) {
     super(message, cause);
-    this.userMessage = "Payment provider error. Please try again.";
   }
 }
 
 export class DuplicatePaymentError extends WalletError {
   readonly code = "DUPLICATE_PAYMENT";
   readonly category = "PAYMENT" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.DUPLICATE_PAYMENT;
 
   constructor(message: string) {
     super(message);
-    this.userMessage = "This payment has already been processed.";
   }
 }
 
 export class UserValidationError extends WalletError {
   readonly code = "USER_VALIDATION_ERROR";
   readonly category = "VALIDATION" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.USER_VALIDATION_FAILED;
 
   constructor(message: string) {
     super(message);
-    this.userMessage = "Invalid user information. Please log in again.";
   }
 }
 
 export class PackageValidationError extends WalletError {
   readonly code = "PACKAGE_VALIDATION_ERROR";
   readonly category = "VALIDATION" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.PACKAGE_VALIDATION_FAILED;
 
   constructor(message: string) {
     super(message);
-    this.userMessage = "Invalid credit package. Please select a valid package.";
   }
 }
 
 export class ReceiptValidationError extends WalletError {
   readonly code = "RECEIPT_VALIDATION_ERROR";
   readonly category = "VALIDATION" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.RECEIPT_VALIDATION_FAILED;
 
   constructor(message: string) {
     super(message);
-    this.userMessage = "Invalid payment receipt. Please contact support.";
   }
 }
 
 export class TransactionError extends WalletError {
   readonly code = "TRANSACTION_ERROR";
   readonly category = "INFRASTRUCTURE" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.TRANSACTION_FAILED;
 
   constructor(message: string, cause?: Error) {
     super(message, cause);
-    this.userMessage = "Transaction failed. Please try again.";
   }
 }
 
 export class NetworkError extends WalletError {
   readonly code = "NETWORK_ERROR";
   readonly category = "INFRASTRUCTURE" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.NETWORK_ERROR;
 
   constructor(message: string, cause?: Error) {
     super(message, cause);
-    this.userMessage = "Network error. Please check your connection.";
   }
 }
 
 export class CreditLimitError extends WalletError {
   readonly code = "CREDIT_LIMIT_ERROR";
   readonly category = "BUSINESS" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.CREDIT_LIMIT_EXCEEDED;
 
   constructor(message: string) {
     super(message);
-    this.userMessage = "Credit limit exceeded. Please contact support.";
   }
 }
 
 export class RefundError extends WalletError {
   readonly code = "REFUND_ERROR";
   readonly category = "BUSINESS" as const;
-  readonly userMessage: string;
+  readonly userMessage = WALLET_ERROR_MESSAGES.REFUND_FAILED;
 
   constructor(message: string, cause?: Error) {
     super(message, cause);
-    this.userMessage = "Refund failed. Please contact support.";
   }
 }
 

package/src/domains/wallet/domain/errors/WalletErrorMessages.ts

@@ -0,0 +1,17 @@
+/**
+ * Wallet Error Messages
+ * Centralized error user messages for wallet operations
+ */
+
+export const WALLET_ERROR_MESSAGES = {
+  PAYMENT_VALIDATION_FAILED: "Payment validation failed. Please try again.",
+  PAYMENT_PROVIDER_ERROR: "Payment provider error. Please try again.",
+  DUPLICATE_PAYMENT: "This payment has already been processed.",
+  USER_VALIDATION_FAILED: "Invalid user information. Please log in again.",
+  PACKAGE_VALIDATION_FAILED: "Invalid credit package. Please select a valid package.",
+  RECEIPT_VALIDATION_FAILED: "Invalid payment receipt. Please contact support.",
+  TRANSACTION_FAILED: "Transaction failed. Please try again.",
+  NETWORK_ERROR: "Network error. Please check your connection.",
+  CREDIT_LIMIT_EXCEEDED: "Credit limit exceeded. Please contact support.",
+  REFUND_FAILED: "Refund failed. Please contact support.",
+} as const;

package/src/presentation/components/details/PremiumDetailsCard.styles.ts

@@ -0,0 +1,54 @@
+/**
+ * Premium Details Card Styles
+ * StyleSheet for PremiumDetailsCard component
+ */
+
+import { StyleSheet } from "react-native";
+
+export const styles = StyleSheet.create({
+  card: {
+    borderRadius: 12,
+    padding: 16,
+    gap: 12,
+  },
+  header: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+  },
+  headerTitleContainer: {
+    flex: 1,
+    marginRight: 12,
+  },
+  freeUserHeader: {
+    marginBottom: 4,
+  },
+  freeUserTextContainer: {
+    gap: 6,
+  },
+  premiumButton: {
+    paddingVertical: 16,
+    borderRadius: 12,
+    alignItems: "center",
+  },
+  detailsSection: {
+    gap: 8,
+  },
+  sectionTitle: {
+    marginBottom: 4,
+    fontWeight: "600",
+  },
+  creditsSection: {
+    gap: 8,
+    paddingTop: 12,
+    borderTopWidth: 1,
+  },
+  actionsSection: {
+    gap: 8,
+  },
+  secondaryButton: {
+    paddingVertical: 12,
+    borderRadius: 8,
+    alignItems: "center",
+  },
+});

package/src/presentation/components/details/PremiumDetailsCard.tsx

@@ -5,11 +5,12 @@
  */
 
 import React from "react";
-import { View, StyleSheet, TouchableOpacity } from "react-native";
+import { View, TouchableOpacity } from "react-native";
 import { useAppDesignTokens, AtomicText } from "@umituz/react-native-design-system";
 import { PremiumStatusBadge } from "./PremiumStatusBadge";
 import { DetailRow } from "./DetailRow";
 import { CreditRow } from "./CreditRow";
+import { styles } from "./PremiumDetailsCard.styles";
 import type { PremiumDetailsCardProps } from "./PremiumDetailsCardTypes";
 
 export type { CreditInfo, PremiumDetailsTranslations, PremiumDetailsCardProps } from "./PremiumDetailsCardTypes";
@@ -144,51 +145,3 @@ export const PremiumDetailsCard: React.FC<PremiumDetailsCardProps> = ({
     </View>
   );
 };
-
-const styles = StyleSheet.create({
-  card: {
-    borderRadius: 12,
-    padding: 16,
-    gap: 12,
-  },
-  header: {
-    flexDirection: "row",
-    justifyContent: "space-between",
-    alignItems: "center",
-  },
-  headerTitleContainer: {
-    flex: 1,
-    marginRight: 12,
-  },
-  freeUserHeader: {
-    marginBottom: 4,
-  },
-  freeUserTextContainer: {
-    gap: 6,
-  },
-  premiumButton: {
-    paddingVertical: 16,
-    borderRadius: 12,
-    alignItems: "center",
-  },
-  detailsSection: {
-    gap: 8,
-  },
-  sectionTitle: {
-    marginBottom: 4,
-    fontWeight: "600",
-  },
-  creditsSection: {
-    gap: 8,
-    paddingTop: 12,
-    borderTopWidth: 1,
-  },
-  actionsSection: {
-    gap: 8,
-  },
-  secondaryButton: {
-    paddingVertical: 12,
-    borderRadius: 8,
-    alignItems: "center",
-  },
-});

package/src/presentation/hooks/paywall/usePaywallOperations.ts

@@ -15,7 +15,7 @@ const RERENDER_DELAY_MS = 100;
 export function usePaywallOperations({
   userId,
   isAnonymous,
-  onPaywallClose,
+  onPaywallClose: _onPaywallClose,
   onPurchaseSuccess,
   onAuthRequired,
 }: PaywallOperationsProps): PaywallOperationsResult {
@@ -54,7 +54,7 @@ export function usePaywallOperations({
       else showError();
       return success;
     },
-    [isAuthenticated, purchasePackage, onPurchaseSuccess, onPaywallClose, onAuthRequired, showError]
+    [isAuthenticated, purchasePackage, onPurchaseSuccess, onAuthRequired, showError]
   );
 
   const handleRestore = useCallback(async (): Promise<boolean> => {

package/src/presentation/hooks/useSubscription.ts

@@ -4,9 +4,13 @@
  */
 
 import { useState, useCallback } from 'react';
-import { getSubscriptionService } from '../../infrastructure/services/SubscriptionService';
 import type { SubscriptionStatus } from '../../domain/entities/SubscriptionStatus';
 import { isSubscriptionValid } from '../../domain/entities/SubscriptionStatus';
+import {
+  checkSubscriptionService,
+  validateUserId,
+  executeSubscriptionOperation,
+} from './useSubscription.utils';
 
 export interface UseSubscriptionResult {
   /** Current subscription status */
@@ -45,120 +49,96 @@ export function useSubscription(): UseSubscriptionResult {
   const [error, setError] = useState<string | null>(null);
 
   const loadStatus = useCallback(async (userId: string) => {
-    if (!userId) {
-      setError('User ID is required');
+    const validationError = validateUserId(userId);
+    if (validationError) {
+      setError(validationError);
       return;
     }
 
-    const service = getSubscriptionService();
-    if (!service) {
-      setError('Subscription service is not initialized');
+    const serviceCheck = checkSubscriptionService();
+    if (!serviceCheck.success) {
+      setError(serviceCheck.error || "Service error");
       return;
     }
 
-    setLoading(true);
-    setError(null);
-
-    try {
-      const subscriptionStatus = await service.getSubscriptionStatus(userId);
-      setStatus(subscriptionStatus);
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : 'Failed to load subscription status';
-      setError(errorMessage);
-    } finally {
-      setLoading(false);
-    }
+    await executeSubscriptionOperation(
+      () => serviceCheck.service!.getSubscriptionStatus(userId),
+      setLoading,
+      setError,
+      (result) => setStatus(result)
+    );
   }, []);
 
   const refreshStatus = useCallback(async (userId: string) => {
-    if (!userId) {
-      setError('User ID is required');
+    const validationError = validateUserId(userId);
+    if (validationError) {
+      setError(validationError);
       return;
     }
 
-    const service = getSubscriptionService();
-    if (!service) {
-      setError('Subscription service is not initialized');
+    const serviceCheck = checkSubscriptionService();
+    if (!serviceCheck.success) {
+      setError(serviceCheck.error || "Service error");
       return;
     }
 
-    setLoading(true);
-    setError(null);
-
-    try {
-      const subscriptionStatus = await service.getSubscriptionStatus(userId);
-      setStatus(subscriptionStatus);
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : 'Failed to refresh subscription status';
-      setError(errorMessage);
-    } finally {
-      setLoading(false);
-    }
+    await executeSubscriptionOperation(
+      () => serviceCheck.service!.getSubscriptionStatus(userId),
+      setLoading,
+      setError,
+      (result) => setStatus(result)
+    );
   }, []);
 
   const activateSubscription = useCallback(
     async (userId: string, productId: string, expiresAt: string | null) => {
-      if (!userId || !productId) {
-        setError('User ID and Product ID are required');
+      const validationError = validateUserId(userId);
+      if (validationError) {
+        setError(validationError);
         return;
       }
 
-      const service = getSubscriptionService();
-      if (!service) {
-        setError('Subscription service is not initialized');
+      if (!productId) {
+        setError("Product ID is required");
         return;
       }
 
-      setLoading(true);
-      setError(null);
-
-      try {
-        const updatedStatus = await service.activateSubscription(
-          userId,
-          productId,
-          expiresAt,
-        );
-        setStatus(updatedStatus);
-      } catch (err) {
-        const errorMessage =
-          err instanceof Error ? err.message : 'Failed to activate subscription';
-        setError(errorMessage);
-        throw err;
-      } finally {
-        setLoading(false);
+      const serviceCheck = checkSubscriptionService();
+      if (!serviceCheck.success) {
+        setError(serviceCheck.error || "Service error");
+        return;
       }
+
+      await executeSubscriptionOperation(
+        () =>
+          serviceCheck.service!.activateSubscription(userId, productId, expiresAt),
+        setLoading,
+        setError,
+        (result) => setStatus(result)
+      );
     },
-    [],
+    []
   );
 
   const deactivateSubscription = useCallback(async (userId: string) => {
-    if (!userId) {
-      setError('User ID is required');
+    const validationError = validateUserId(userId);
+    if (validationError) {
+      setError(validationError);
       return;
     }
 
-    const service = getSubscriptionService();
-    if (!service) {
-      setError('Subscription service is not initialized');
+    const serviceCheck = checkSubscriptionService();
+    if (!serviceCheck.success) {
+      setError(serviceCheck.error || "Service error");
       return;
     }
 
-    setLoading(true);
-    setError(null);
-
-    try {
-      const updatedStatus = await service.deactivateSubscription(userId);
-      setStatus(updatedStatus);
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : 'Failed to deactivate subscription';
-      setError(errorMessage);
-      throw err;
-    } finally {
-      setLoading(false);
-    }
+    await executeSubscriptionOperation(
+      () => serviceCheck.service!.deactivateSubscription(userId),
+      setLoading,
+      setError,
+      (result) => setStatus(result)
+    );
   }, []);
 
   const isPremium = isSubscriptionValid(status);

package/src/presentation/hooks/useSubscription.utils.ts

@@ -0,0 +1,78 @@
+/**
+ * useSubscription Utilities
+ * Shared utilities for subscription hook operations
+ */
+
+export type AsyncSubscriptionOperation<T> = () => Promise<T>;
+
+/**
+ * Result of a subscription service initialization check
+ */
+export interface ServiceCheckResult {
+  success: boolean;
+  service: ReturnType<typeof import("../../infrastructure/services/SubscriptionService").getSubscriptionService> | null;
+  error?: string;
+}
+
+/**
+ * Checks if subscription service is initialized
+ * Returns service instance or error
+ */
+export function checkSubscriptionService(): ServiceCheckResult {
+  const { getSubscriptionService } = require("../../infrastructure/services/SubscriptionService");
+  const service = getSubscriptionService();
+
+  if (!service) {
+    return {
+      success: false,
+      service: null,
+      error: "Subscription service is not initialized",
+    };
+  }
+
+  return { success: true, service, error: undefined };
+}
+
+/**
+ * Validates user ID
+ */
+export function validateUserId(userId: string): string | null {
+  if (!userId) {
+    return "User ID is required";
+  }
+  return null;
+}
+
+/**
+ * Wraps async subscription operations with loading state, error handling, and state updates
+ */
+export async function executeSubscriptionOperation<T>(
+  operation: AsyncSubscriptionOperation<T>,
+  setLoading: (loading: boolean) => void,
+  setError: (error: string | null) => void,
+  onSuccess?: (result: T) => void
+): Promise<void> {
+  setLoading(true);
+  setError(null);
+
+  try {
+    const result = await operation();
+    if (onSuccess) {
+      onSuccess(result);
+    }
+  } catch (err) {
+    const errorMessage =
+      err instanceof Error ? err.message : "Operation failed";
+    setError(errorMessage);
+    throw err;
+  } finally {
+    setLoading(false);
+  }
+}
+
+/**
+ * Formats error message from unknown error
+ */
+export function formatErrorMessage(err: unknown, fallbackMessage: string): string {
+  return err instanceof Error ? err.message : fallbackMessage;
+}

package/src/presentation/hooks/useSubscriptionSettingsConfig.ts

@@ -15,6 +15,7 @@ import {
     formatDateForLocale,
     calculateDaysRemaining,
 } from "../utils/subscriptionDateUtils";
+import { useCreditsArray, getSubscriptionStatusType } from "./useSubscriptionSettingsConfig.utils";
 import type {
   SubscriptionSettingsConfig,
   SubscriptionStatusType,
@@ -104,23 +105,10 @@ export const useSubscriptionSettingsConfig = (
   );
 
   // Status type
-  const statusType: SubscriptionStatusType = isPremium ? "active" : "none";
+  const statusType: SubscriptionStatusType = getSubscriptionStatusType(isPremium);
 
   // Credits array
-  const creditsArray = useMemo(() => {
-    if (!credits) return [];
-    const total = getCreditLimit
-      ? getCreditLimit(credits.imageCredits)
-      : credits.imageCredits;
-    return [
-      {
-        id: "image",
-        label: translations.imageCreditsLabel || "Image Credits",
-        current: credits.imageCredits,
-        total,
-      },
-    ];
-  }, [credits, getCreditLimit, translations.imageCreditsLabel]);
+  const creditsArray = useCreditsArray(credits, getCreditLimit, translations);
 
   // Build config
   const config = useMemo(

package/src/presentation/hooks/useSubscriptionSettingsConfig.utils.ts

@@ -0,0 +1,48 @@
+/**
+ * useSubscriptionSettingsConfig Utilities
+ * Helper functions for subscription settings config
+ */
+
+import { useMemo } from "react";
+import type { UserCredits } from "../../domain/entities/Credits";
+import type { SubscriptionSettingsTranslations } from "../types/SubscriptionSettingsTypes";
+
+export interface CreditsInfo {
+  id: string;
+  label: string;
+  current: number;
+  total: number;
+}
+
+/**
+ * Builds credits array for display
+ */
+export function useCreditsArray(
+  credits: UserCredits | null | undefined,
+  getCreditLimit: ((credits: number) => number) | undefined,
+  translations: SubscriptionSettingsTranslations
+): CreditsInfo[] {
+  return useMemo(() => {
+    if (!credits) return [];
+    const total = getCreditLimit
+      ? getCreditLimit(credits.imageCredits)
+      : credits.imageCredits;
+    return [
+      {
+        id: "image",
+        label: translations.imageCreditsLabel || "Image Credits",
+        current: credits.imageCredits,
+        total,
+      },
+    ];
+  }, [credits, getCreditLimit, translations.imageCreditsLabel]);
+}
+
+/**
+ * Calculates subscription status type
+ */
+export function getSubscriptionStatusType(
+  isPremium: boolean
+): "active" | "none" {
+  return isPremium ? "active" : "none";
+}