@umituz/react-native-subscription 2.14.94 → 2.14.96

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.14.94",
+  "version": "2.14.96",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,10 +32,9 @@
     "url": "git+https://github.com/umituz/react-native-subscription.git"
   },
   "dependencies": {
-    "@umituz/react-native-design-system": "latest",
     "@umituz/react-native-firebase": "latest",
-    "@umituz/react-native-localization": "latest",
-    "@umituz/react-native-storage": "latest"
+    "@umituz/react-native-storage": "latest",
+    "@umituz/react-native-timezone": "latest"
   },
   "peerDependencies": {
     "@tanstack/react-query": ">=5.0.0",
@@ -60,12 +59,12 @@
     "@types/react": "~19.1.10",
     "@typescript-eslint/eslint-plugin": "^8.50.1",
     "@typescript-eslint/parser": "^8.50.1",
-    "@umituz/react-native-auth": "*",
-    "@umituz/react-native-design-system": "*",
-    "@umituz/react-native-filesystem": "^2.1.20",
+    "@umituz/react-native-auth": "^3.4.26",
+    "@umituz/react-native-design-system": "^2.6.82",
+    "@umituz/react-native-filesystem": "^2.1.21",
     "@umituz/react-native-firebase": "*",
     "@umituz/react-native-haptics": "^1.0.5",
-    "@umituz/react-native-localization": "*",
+    "@umituz/react-native-localization": "^3.5.52",
     "@umituz/react-native-storage": "*",
     "@umituz/react-native-uuid": "^1.2.6",
     "eslint": "^9.39.2",

package/src/domain/entities/Credits.ts

@@ -5,23 +5,34 @@
  * Designed to be used across hundreds of apps with configurable limits.
  */
 
+import type { SubscriptionPackageType } from "../../utils/packageTypeDetector";
+
 export type CreditType = "text" | "image";
 
 export interface UserCredits {
-  textCredits: number;
-  imageCredits: number;
-  purchasedAt: Date;
-  lastUpdatedAt: Date;
+  credits: number;
+  purchasedAt: Date | null;
+  lastUpdatedAt: Date | null;
+}
+
+export interface CreditAllocation {
+  credits: number;
 }
 
+export type PackageAllocationMap = Record<
+  Exclude<SubscriptionPackageType, "unknown">,
+  CreditAllocation
+>;
+
 export interface CreditsConfig {
   collectionName: string;
-  textCreditLimit: number;
-  imageCreditLimit: number;
+  creditLimit: number;
   /** When true, stores credits at users/{userId}/credits instead of {collectionName}/{userId} */
   useUserSubcollection?: boolean;
   /** Credit amounts per product ID for consumable credit packages */
   creditPackageAmounts?: Record<string, number>;
+  /** Credit allocations for different subscription types (weekly, monthly, yearly) */
+  packageAllocations?: PackageAllocationMap;
 }
 
 export interface CreditsResult<T = UserCredits> {
@@ -44,6 +55,5 @@ export interface DeductCreditsResult {
 
 export const DEFAULT_CREDITS_CONFIG: CreditsConfig = {
   collectionName: "user_credits",
-  textCreditLimit: 1000,
-  imageCreditLimit: 100,
+  creditLimit: 100,
 };

package/src/domain/entities/SubscriptionStatus.ts

@@ -1,6 +1,4 @@
-/**
- * Subscription Status Entity
- */
+import { timezoneService } from "@umituz/react-native-timezone";
 
 export const SUBSCRIPTION_STATUS = {
   ACTIVE: 'active',
@@ -34,12 +32,12 @@ export const createDefaultSubscriptionStatus = (): SubscriptionStatus => ({
 export const isSubscriptionValid = (status: SubscriptionStatus | null): boolean => {
     if (!status || !status.isPremium) return false;
     if (!status.expiresAt) return true; // Lifetime
-    return new Date(status.expiresAt).getTime() > Date.now();
+    
+    return timezoneService.isFuture(new Date(status.expiresAt));
 };
 
 export const calculateDaysRemaining = (expiresAt: string | null): number | null => {
     if (!expiresAt) return null;
-    const diff = new Date(expiresAt).getTime() - Date.now();
-    return Math.max(0, Math.ceil(diff / (1000 * 60 * 60 * 24)));
+    return timezoneService.getDaysUntil(new Date(expiresAt));
 };
 

package/src/domains/wallet/presentation/components/TransactionItem.tsx

@@ -12,6 +12,7 @@ import {
     AtomicText,
     AtomicIcon,
 } from "@umituz/react-native-design-system";
+import { timezoneService } from "@umituz/react-native-timezone";
 import type { CreditLog, TransactionReason } from "../../domain/types/transaction.types";
 
 export interface TransactionItemTranslations {
@@ -46,14 +47,7 @@ const getReasonIcon = (reason: TransactionReason): string => {
 };
 
 const defaultDateFormatter = (timestamp: number): string => {
-  const date = new Date(timestamp);
-  const d = String(date.getDate()).padStart(2, '0');
-  const m = String(date.getMonth() + 1).padStart(2, '0');
-  const y = date.getFullYear();
-  const th = String(date.getHours()).padStart(2, '0');
-  const tm = String(date.getMinutes()).padStart(2, '0');
-  
-  return `${d}.${m}.${y} ${th}:${tm}`;
+  return timezoneService.formatToDisplayDateTime(new Date(timestamp));
 };
 
 export const TransactionItem: React.FC<TransactionItemProps> = ({

package/src/domains/wallet/presentation/hooks/useWallet.ts

@@ -25,8 +25,6 @@ export interface UseWalletParams {
 
 export interface UseWalletResult {
   balance: number;
-  textCredits: number;
-  imageCredits: number;
   balanceLoading: boolean;
   transactions: CreditLog[];
   transactionsLoading: boolean;
@@ -58,8 +56,7 @@ export function useWallet({
     credits,
     isLoading: balanceLoading,
     refetch: refetchBalance,
-    hasTextCredits,
-    hasImageCredits,
+    hasCredits,
   } = useCredits(creditsParams);
 
   const {
@@ -69,8 +66,7 @@ export function useWallet({
   } = useTransactionHistory(transactionParams);
 
   const balance = useMemo(() => {
-    if (!credits) return 0;
-    return credits.textCredits + credits.imageCredits;
+    return credits?.credits ?? 0;
   }, [credits]);
 
   const refetchAll = useCallback(() => {
@@ -80,12 +76,10 @@ export function useWallet({
 
   return {
     balance,
-    textCredits: credits?.textCredits ?? 0,
-    imageCredits: credits?.imageCredits ?? 0,
     balanceLoading,
     transactions,
     transactionsLoading,
-    hasCredits: hasTextCredits || hasImageCredits,
+    hasCredits,
     refetchBalance,
     refetchTransactions,
     refetchAll,

package/src/infrastructure/mappers/CreditsMapper.ts

@@ -1,25 +1,18 @@
-/**
- * Credits Mapper
- * Maps Firestore data to UserCredits entity and vice-versa.
- */
-
 import type { UserCredits } from "../../domain/entities/Credits";
 import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
 
 export class CreditsMapper {
   static toEntity(snapData: UserCreditsDocumentRead): UserCredits {
     return {
-      textCredits: snapData.textCredits,
-      imageCredits: snapData.imageCredits,
-      purchasedAt: snapData.purchasedAt?.toDate?.() || new Date(),
-      lastUpdatedAt: snapData.lastUpdatedAt?.toDate?.() || new Date(),
+      credits: snapData.credits,
+      purchasedAt: snapData.purchasedAt?.toDate?.() || null,
+      lastUpdatedAt: snapData.lastUpdatedAt?.toDate?.() || null,
     };
   }
 
   static toFirestore(data: Partial<UserCredits>): Record<string, any> {
     return {
-      textCredits: data.textCredits,
-      imageCredits: data.imageCredits,
+      credits: data.credits,
       // Timestamps are usually handled by serverTimestamp() in repos, 
       // but we can map them if needed.
     };

package/src/infrastructure/models/UserCreditsDocument.ts

@@ -5,8 +5,7 @@ export interface FirestoreTimestamp {
 
 // Document structure when READING from Firestore
 export interface UserCreditsDocumentRead {
-    textCredits: number;
-    imageCredits: number;
+    credits: number;
     purchasedAt?: FirestoreTimestamp;
     lastUpdatedAt?: FirestoreTimestamp;
     lastPurchaseAt?: FirestoreTimestamp;

package/src/infrastructure/repositories/CreditsRepository.ts

@@ -4,7 +4,7 @@
 
 import { doc, getDoc, runTransaction, serverTimestamp, type Firestore, type Transaction } from "firebase/firestore";
 import { BaseRepository, getFirestore } from "@umituz/react-native-firebase";
-import type { CreditType, CreditsConfig, CreditsResult, DeductCreditsResult } from "../../domain/entities/Credits";
+import type { CreditsConfig, CreditsResult, DeductCreditsResult } from "../../domain/entities/Credits";
 import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
 import { initializeCreditsTransaction } from "../services/CreditsInitializer";
 import { detectPackageType } from "../../utils/packageTypeDetector";
@@ -39,10 +39,11 @@ export class CreditsRepository extends BaseRepository {
       let cfg = { ...this.config };
       if (productId) {
         const amt = this.config.creditPackageAmounts?.[productId];
-        if (amt) cfg = { ...cfg, imageCreditLimit: amt, textCreditLimit: amt };
+        if (amt) cfg = { ...cfg, creditLimit: amt };
         else {
-          const alloc = getCreditAllocation(detectPackageType(productId));
-          if (alloc) cfg = { ...cfg, imageCreditLimit: alloc.imageCredits, textCreditLimit: alloc.textCredits };
+          const packageType = detectPackageType(productId);
+          const dynamicLimit = getCreditAllocation(packageType, this.config.packageAllocations);
+          if (dynamicLimit !== null) cfg = { ...cfg, creditLimit: dynamicLimit };
         }
       }
       const res = await initializeCreditsTransaction(db, this.getRef(db, userId), cfg, purchaseId);
@@ -50,25 +51,24 @@ export class CreditsRepository extends BaseRepository {
         success: true, 
         data: CreditsMapper.toEntity({
             ...res,
-            purchasedAt: { toDate: () => new Date() } as any,
-            lastUpdatedAt: { toDate: () => new Date() } as any,
+            purchasedAt: undefined,
+            lastUpdatedAt: undefined,
         }) 
       };
     } catch (e: any) { return { success: false, error: { message: e.message, code: "INIT_ERR" } }; }
   }
 
-  async deductCredit(userId: string, type: CreditType): Promise<DeductCreditsResult> {
+  async deductCredit(userId: string, cost: number = 1): Promise<DeductCreditsResult> {
     const db = getFirestore();
     if (!db) return { success: false, error: { message: "No DB", code: "ERR" } };
-    const field = type === "text" ? "textCredits" : "imageCredits";
     try {
       const remaining = await runTransaction(db, async (tx: Transaction) => {
         const docSnap = await tx.get(this.getRef(db, userId));
         if (!docSnap.exists()) throw new Error("NO_CREDITS");
-        const current = docSnap.data()[field] as number;
-        if (current <= 0) throw new Error("CREDITS_EXHAUSTED");
-        const updated = current - 1;
-        tx.update(this.getRef(db, userId), { [field]: updated, lastUpdatedAt: serverTimestamp() });
+        const current = docSnap.data().credits as number;
+        if (current < cost) throw new Error("CREDITS_EXHAUSTED");
+        const updated = current - cost;
+        tx.update(this.getRef(db, userId), { credits: updated, lastUpdatedAt: serverTimestamp() });
         return updated;
       });
       return { success: true, remainingCredits: remaining };
@@ -78,9 +78,9 @@ export class CreditsRepository extends BaseRepository {
     }
   }
 
-  async hasCredits(userId: string, type: CreditType): Promise<boolean> {
+  async hasCredits(userId: string, cost: number = 1): Promise<boolean> {
     const res = await this.getCredits(userId);
-    return !!(res.success && res.data && (type === "text" ? res.data.textCredits : res.data.imageCredits) > 0);
+    return !!(res.success && res.data && res.data.credits >= cost);
   }
 }
 

package/src/infrastructure/services/ActivationHandler.ts

@@ -1,8 +1,4 @@
-/**
- * Activation Handler
- * Handles subscription activation and deactivation
- */
-
+import { timezoneService } from "@umituz/react-native-timezone";
 import type { ISubscriptionRepository } from "../../application/ports/ISubscriptionRepository";
 import type { SubscriptionStatus } from "../../domain/entities/SubscriptionStatus";
 import { SubscriptionRepositoryError } from "../../domain/errors/SubscriptionError";
@@ -32,11 +28,12 @@ export async function activateSubscription(
         isPremium: true,
         productId,
         expiresAt,
-        purchasedAt: new Date().toISOString(),
-        syncedAt: new Date().toISOString(),
+        purchasedAt: timezoneService.getCurrentISOString(),
+        syncedAt: timezoneService.getCurrentISOString(),
       }
     );
 
+
     await notifyStatusChange(config, userId, updatedStatus);
     return updatedStatus;
   } catch (error) {

package/src/infrastructure/services/CreditsInitializer.ts

@@ -10,8 +10,7 @@ import type { CreditsConfig } from "../../domain/entities/Credits";
 import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
 
 interface InitializationResult {
-    textCredits: number;
-    imageCredits: number;
+    credits: number;
 }
 
 export async function initializeCreditsTransaction(
@@ -24,8 +23,7 @@ export async function initializeCreditsTransaction(
         const creditsDoc = await transaction.get(creditsRef);
         const now = serverTimestamp();
 
-        let newTextCredits = config.textCreditLimit;
-        let newImageCredits = config.imageCreditLimit;
+        let newCredits = config.creditLimit;
         let purchasedAt = now;
         let processedPurchases: string[] = [];
 
@@ -35,14 +33,12 @@ export async function initializeCreditsTransaction(
 
             if (purchaseId && processedPurchases.includes(purchaseId)) {
                 return {
-                    textCredits: existing.textCredits,
-                    imageCredits: existing.imageCredits,
+                    credits: existing.credits,
                     alreadyProcessed: true,
-                };
+                } as any;
             }
 
-            newTextCredits = (existing.textCredits || 0) + config.textCreditLimit;
-            newImageCredits = (existing.imageCredits || 0) + config.imageCreditLimit;
+            newCredits = (existing.credits || 0) + config.creditLimit;
 
             if (existing.purchasedAt) {
                 purchasedAt = existing.purchasedAt as unknown as FieldValue;
@@ -54,8 +50,7 @@ export async function initializeCreditsTransaction(
         }
 
         const creditsData = {
-            textCredits: newTextCredits,
-            imageCredits: newImageCredits,
+            credits: newCredits,
             purchasedAt,
             lastUpdatedAt: now,
             lastPurchaseAt: now,
@@ -65,6 +60,6 @@ export async function initializeCreditsTransaction(
         // Use merge:true to avoid overwriting other user fields
         transaction.set(creditsRef, creditsData, { merge: true });
 
-        return { textCredits: newTextCredits, imageCredits: newImageCredits };
+        return { credits: newCredits };
     });
 }

package/src/infrastructure/services/SubscriptionService.ts

@@ -3,6 +3,7 @@
  * Database-first subscription management
  */
 
+import { timezoneService } from "@umituz/react-native-timezone";
 import type { ISubscriptionService } from "../../application/ports/ISubscriptionService";
 import type { ISubscriptionRepository } from "../../application/ports/ISubscriptionRepository";
 import type { SubscriptionStatus } from "../../domain/entities/SubscriptionStatus";
@@ -89,7 +90,7 @@ export class SubscriptionService implements ISubscriptionService {
     try {
       const updatesWithSync = {
         ...updates,
-        syncedAt: new Date().toISOString(),
+        syncedAt: timezoneService.getCurrentISOString(),
       };
 
       const updatedStatus = await this.repository.updateSubscriptionStatus(

package/src/presentation/hooks/useCreditChecker.ts

@@ -5,7 +5,6 @@
  */
 
 import { useMemo } from "react";
-import type { CreditType } from "../../domain/entities/Credits";
 import { getCreditsRepository } from "../../infrastructure/repositories/CreditsRepositoryProvider";
 import {
     createCreditChecker,
@@ -13,28 +12,29 @@ import {
 } from "../../utils/creditChecker";
 
 export interface UseCreditCheckerParams {
-  getCreditType: (operationType: string) => CreditType;
+  onCreditDeducted?: (userId: string, cost: number) => void;
 }
 
 export interface UseCreditCheckerResult {
   checkCreditsAvailable: (
     userId: string | undefined,
-    operationType: string
+    cost?: number
   ) => Promise<CreditCheckResult>;
   deductCreditsAfterSuccess: (
     userId: string | undefined,
-    creditType: CreditType
+    cost?: number
   ) => Promise<void>;
 }
 
-export const useCreditChecker = ({
-  getCreditType,
-}: UseCreditCheckerParams): UseCreditCheckerResult => {
+export const useCreditChecker = (
+  params?: UseCreditCheckerParams
+): UseCreditCheckerResult => {
   const repository = getCreditsRepository();
+  const onCreditDeducted = params?.onCreditDeducted;
 
   const checker = useMemo(
-    () => createCreditChecker({ repository, getCreditType }),
-    [getCreditType, repository]
+    () => createCreditChecker({ repository, onCreditDeducted }),
+    [repository, onCreditDeducted]
   );
 
   return checker;

package/src/presentation/hooks/useCredits.ts

@@ -7,7 +7,7 @@
 
 import { useQuery } from "@tanstack/react-query";
 import { useCallback, useMemo } from "react";
-import type { UserCredits, CreditType } from "../../domain/entities/Credits";
+import type { UserCredits } from "../../domain/entities/Credits";
 import {
     getCreditsRepository,
     getCreditsConfig,
@@ -42,13 +42,11 @@ export interface UseCreditsResult {
   credits: UserCredits | null;
   isLoading: boolean;
   error: Error | null;
-  hasTextCredits: boolean;
-  hasImageCredits: boolean;
-  textCreditsPercent: number;
-  imageCreditsPercent: number;
+  hasCredits: boolean;
+  creditsPercent: number;
   refetch: () => void;
   /** Check if user can afford a specific credit cost */
-  canAfford: (cost: number, type?: CreditType) => boolean;
+  canAfford: (cost: number) => boolean;
 }
 
 export const useCredits = ({
@@ -86,30 +84,22 @@ export const useCredits = ({
 
   // Memoize derived values to prevent unnecessary re-renders
   const derivedValues = useMemo(() => {
-    const hasText = (credits?.textCredits ?? 0) > 0;
-    const hasImage = (credits?.imageCredits ?? 0) > 0;
-    const textPercent = credits
-      ? Math.round((credits.textCredits / config.textCreditLimit) * 100)
-      : 0;
-    const imagePercent = credits
-      ? Math.round((credits.imageCredits / config.imageCreditLimit) * 100)
+    const has = (credits?.credits ?? 0) > 0;
+    const percent = credits
+      ? Math.round((credits.credits / config.creditLimit) * 100)
       : 0;
 
     return {
-      hasTextCredits: hasText,
-      hasImageCredits: hasImage,
-      textCreditsPercent: textPercent,
-      imageCreditsPercent: imagePercent,
+      hasCredits: has,
+      creditsPercent: percent,
     };
-  }, [credits, config.textCreditLimit, config.imageCreditLimit]);
+  }, [credits, config.creditLimit]);
 
   // Memoize canAfford to prevent recreation on every render
   const canAfford = useCallback(
-    (cost: number, type: CreditType = "text"): boolean => {
+    (cost: number): boolean => {
       if (!credits) return false;
-      return type === "text"
-        ? credits.textCredits >= cost
-        : credits.imageCredits >= cost;
+      return credits.credits >= cost;
     },
     [credits]
   );
@@ -118,23 +108,17 @@ export const useCredits = ({
     credits,
     isLoading,
     error: error as Error | null,
-    hasTextCredits: derivedValues.hasTextCredits,
-    hasImageCredits: derivedValues.hasImageCredits,
-    textCreditsPercent: derivedValues.textCreditsPercent,
-    imageCreditsPercent: derivedValues.imageCreditsPercent,
+    hasCredits: derivedValues.hasCredits,
+    creditsPercent: derivedValues.creditsPercent,
     refetch,
     canAfford,
   };
 };
 
 export const useHasCredits = (
-  userId: string | undefined,
-  creditType: CreditType
+  userId: string | undefined
 ): boolean => {
   const { credits } = useCredits({ userId });
   if (!credits) return false;
-
-  return creditType === "text"
-    ? credits.textCredits > 0
-    : credits.imageCredits > 0;
+  return credits.credits > 0;
 };

package/src/presentation/hooks/useDeductCredit.ts

@@ -5,18 +5,20 @@
 
 import { useCallback } from "react";
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import type { CreditType, UserCredits } from "../../domain/entities/Credits";
+import type { UserCredits } from "../../domain/entities/Credits";
 import { getCreditsRepository } from "../../infrastructure/repositories/CreditsRepositoryProvider";
 import { creditsQueryKeys } from "./useCredits";
 
+import { timezoneService } from "@umituz/react-native-timezone";
+
 export interface UseDeductCreditParams {
   userId: string | undefined;
   onCreditsExhausted?: () => void;
 }
 
 export interface UseDeductCreditResult {
-  deductCredit: (creditType: CreditType) => Promise<boolean>;
-  deductCredits: (cost: number, creditType?: CreditType) => Promise<boolean>;
+  deductCredit: (cost?: number) => Promise<boolean>;
+  deductCredits: (cost: number) => Promise<boolean>;
   isDeducting: boolean;
 }
 
@@ -28,22 +30,25 @@ export const useDeductCredit = ({
   const queryClient = useQueryClient();
 
   const mutation = useMutation({
-    mutationFn: async (creditType: CreditType) => {
+    mutationFn: async (cost: number) => {
       if (!userId) throw new Error("User not authenticated");
-      return repository.deductCredit(userId, creditType);
+      return repository.deductCredit(userId, cost);
     },
-    onMutate: async (creditType: CreditType) => {
+    onMutate: async (cost: number) => {
       if (!userId) return;
       await queryClient.cancelQueries({ queryKey: creditsQueryKeys.user(userId) });
       const previousCredits = queryClient.getQueryData<UserCredits>(creditsQueryKeys.user(userId));
       queryClient.setQueryData<UserCredits | null>(creditsQueryKeys.user(userId), (old) => {
         if (!old) return old;
-        const field = creditType === "text" ? "textCredits" : "imageCredits";
-        return { ...old, [field]: Math.max(0, old[field] - 1), lastUpdatedAt: new Date() };
+        return { 
+          ...old, 
+          credits: Math.max(0, old.credits - cost), 
+          lastUpdatedAt: timezoneService.getNow() 
+        };
       });
       return { previousCredits };
     },
-    onError: (_err, _type, context) => {
+    onError: (_err, _cost, context) => {
       if (userId && context?.previousCredits) {
         queryClient.setQueryData(creditsQueryKeys.user(userId), context.previousCredits);
       }
@@ -53,9 +58,9 @@ export const useDeductCredit = ({
     },
   });
 
-  const deductCredit = useCallback(async (type: CreditType): Promise<boolean> => {
+  const deductCredit = useCallback(async (cost: number = 1): Promise<boolean> => {
     try {
-      const res = await mutation.mutateAsync(type);
+      const res = await mutation.mutateAsync(cost);
       if (!res.success) {
         if (res.error?.code === "CREDITS_EXHAUSTED") onCreditsExhausted?.();
         return false;
@@ -64,11 +69,8 @@ export const useDeductCredit = ({
     } catch { return false; }
   }, [mutation, onCreditsExhausted]);
 
-  const deductCredits = useCallback(async (cost: number, type: CreditType = "image"): Promise<boolean> => {
-    for (let i = 0; i < cost; i++) {
-      if (!(await deductCredit(type))) return false;
-    }
-    return true;
+  const deductCredits = useCallback(async (cost: number): Promise<boolean> => {
+    return await deductCredit(cost);
   }, [deductCredit]);
 
   return { deductCredit, deductCredits, isDeducting: mutation.isPending };

package/src/presentation/hooks/useDevTestCallbacks.ts

@@ -42,8 +42,7 @@ export const useDevTestCallbacks = (): DevTestActions | undefined => {
       if (__DEV__) {
         console.log("✅ [Dev Test] Renewal completed:", {
           success: result.success,
-          textCredits: result.data?.textCredits,
-          imageCredits: result.data?.imageCredits,
+          credits: result.data?.credits,
         });
       }
 
@@ -51,7 +50,7 @@ export const useDevTestCallbacks = (): DevTestActions | undefined => {
 
       Alert.alert(
         "✅ Test Renewal Success",
-        `Credits Updated!\n\nText: ${result.data?.textCredits || 0}\nImage: ${result.data?.imageCredits || 0}\n\n(ACCUMULATE mode - credits added to existing)`,
+        `Credits Updated!\n\nNew Balance: ${result.data?.credits || 0}\n\n(ACCUMULATE mode - credits added to existing)`,
         [{ text: "OK" }],
       );
     } catch (error) {
@@ -73,7 +72,7 @@ export const useDevTestCallbacks = (): DevTestActions | undefined => {
 
     Alert.alert(
       "📊 Current Credits",
-      `Text Generation: ${credits.textCredits}\nImage Generation: ${credits.imageCredits}\n\nPurchased: ${credits.purchasedAt?.toLocaleDateString() || "N/A"}`,
+      `Credits: ${credits.credits}\n\nPurchased: ${credits.purchasedAt?.toLocaleDateString() || "N/A"}`,
       [{ text: "OK" }],
     );
   }, [credits]);
@@ -113,7 +112,7 @@ export const useDevTestCallbacks = (): DevTestActions | undefined => {
       await refetch();
 
       const duplicateProtectionWorks =
-        result2.data?.textCredits === result1.data?.textCredits;
+        result2.data?.credits === result1.data?.credits;
 
       Alert.alert(
         "Duplicate Test",

package/src/presentation/hooks/useSubscriptionSettingsConfig.ts

@@ -37,7 +37,7 @@ export const useSubscriptionSettingsConfig = (
   const {
     userId,
     translations,
-    getCreditLimit,
+    creditLimit,
     upgradePrompt,
   } = params;
 
@@ -96,7 +96,7 @@ export const useSubscriptionSettingsConfig = (
   const statusType: SubscriptionStatusType = getSubscriptionStatusType(isPremium);
 
   // Credits array
-  const creditsArray = useCreditsArray(credits, getCreditLimit, translations);
+  const creditsArray = useCreditsArray(credits, creditLimit, translations);
 
   // Build config
   const config = useMemo(

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

@@ -19,23 +19,20 @@ export interface CreditsInfo {
  */
 export function useCreditsArray(
   credits: UserCredits | null | undefined,
-  getCreditLimit: ((credits: number) => number) | undefined,
+  creditLimit: 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,
+        id: "credits",
+        label: translations.creditsLabel || "Credits",
+        current: credits.credits,
+        total: creditLimit ?? credits.credits,
       },
     ];
-  }, [credits, getCreditLimit, translations.imageCreditsLabel]);
+  }, [credits, creditLimit, translations.creditsLabel]);
 }
 
 /**

package/src/presentation/types/SubscriptionSettingsTypes.ts

@@ -51,8 +51,8 @@ export interface SubscriptionSettingsTranslations {
   remainingLabel: string;
   manageButton: string;
   upgradeButton: string;
-  /** Credit label (e.g., "Image Credits") */
-  imageCreditsLabel?: string;
+  /** Credit label (e.g., "Credits") */
+  creditsLabel?: string;
 }
 
 /** Parameters for useSubscriptionSettingsConfig hook */
@@ -63,8 +63,8 @@ export interface UseSubscriptionSettingsConfigParams {
   isAnonymous?: boolean;
   /** Translation strings */
   translations: SubscriptionSettingsTranslations;
-  /** Credit limit calculator */
-  getCreditLimit?: (currentCredits: number) => number;
+  /** Fixed credit limit (if not available in UserCredits) */
+  creditLimit?: number;
   /** Upgrade prompt configuration for free users */
   upgradePrompt?: UpgradePromptConfig;
 }

package/src/presentation/utils/subscriptionDateUtils.ts

@@ -1,3 +1,5 @@
+import { timezoneService } from "@umituz/react-native-timezone";
+
 /**
  * Converts Firestore timestamp or Date to ISO string
  */
@@ -17,22 +19,18 @@ export const convertPurchasedAt = (purchasedAt: unknown): string | null => {
     return null;
   }
 
-  return date.toISOString();
+  return timezoneService.formatToISOString(date);
 };
 
 /**
- * Formats a date string to a simple DD.MM.YYYY format
+ * Formats a date string to a simple DD.MM.YYYY format using timezoneService
  */
 export const formatDate = (dateStr: string | null): string | null => {
   if (!dateStr) return null;
   const date = new Date(dateStr);
   if (isNaN(date.getTime())) return null;
   
-  const d = String(date.getDate()).padStart(2, '0');
-  const m = String(date.getMonth() + 1).padStart(2, '0');
-  const y = date.getFullYear();
-  
-  return `${d}.${m}.${y}`;
+  return timezoneService.formatToDisplayDate(date);
 };
 
 

package/src/utils/aiCreditHelpers.ts

@@ -14,7 +14,6 @@
  *   });
  */
 
-import type { CreditType } from "../domain/entities/Credits";
 import type { CreditsRepository } from "../infrastructure/repositories/CreditsRepository";
 import { createCreditChecker } from "./creditChecker";
 
@@ -25,24 +24,24 @@ export interface AICreditHelpersConfig {
   repository: CreditsRepository;
 
   /**
-   * List of operation types that should use "image" credits.
-   * All other types will use "text" credits.
-   * @example ['future_image', 'santa_transform', 'photo_generation']
+   * Optional map of operation types to credit costs.
+   * If an operation isn't in this map, cost defaults to 1.
+   * @example { 'high_res_image': 5, 'text_summary': 1 }
    */
-  imageGenerationTypes: string[];
+  operationCosts?: Record<string, number>;
 
   /**
    * Optional callback called after successful credit deduction.
    * Use this to invalidate TanStack Query cache or trigger UI updates.
    */
-  onCreditDeducted?: (userId: string, creditType: CreditType) => void;
+  onCreditDeducted?: (userId: string, cost: number) => void;
 }
 
 export interface AICreditHelpers {
   /**
    * Check if user has credits for a specific generation type
    * @param userId - User ID
-   * @param generationType - Type of generation (e.g., 'future_image', 'text_summary')
+   * @param generationType - Type of generation
    * @returns boolean indicating if credits are available
    */
   checkCreditsForGeneration: (
@@ -61,11 +60,11 @@ export interface AICreditHelpers {
   ) => Promise<void>;
 
   /**
-   * Get credit type for a generation type (useful for UI display)
+   * Get cost for a generation type
    * @param generationType - Type of generation
-   * @returns "image" or "text"
+   * @returns number of credits
    */
-  getCreditType: (generationType: string) => CreditType;
+  getCost: (generationType: string) => number;
 }
 
 /**
@@ -74,17 +73,16 @@ export interface AICreditHelpers {
 export function createAICreditHelpers(
   config: AICreditHelpersConfig
 ): AICreditHelpers {
-  const { repository, imageGenerationTypes, onCreditDeducted } = config;
+  const { repository, operationCosts = {}, onCreditDeducted } = config;
 
-  // Map generation type to credit type
-  const getCreditType = (generationType: string): CreditType => {
-    return imageGenerationTypes.includes(generationType) ? "image" : "text";
+  // Map generation type to cost
+  const getCost = (generationType: string): number => {
+    return operationCosts[generationType] ?? 1;
   };
 
-  // Create credit checker with the mapping
+  // Create credit checker
   const checker = createCreditChecker({
     repository,
-    getCreditType,
     onCreditDeducted,
   });
 
@@ -93,7 +91,8 @@ export function createAICreditHelpers(
     userId: string | undefined,
     generationType: string
   ): Promise<boolean> => {
-    const result = await checker.checkCreditsAvailable(userId, generationType);
+    const cost = getCost(generationType);
+    const result = await checker.checkCreditsAvailable(userId, cost);
     return result.success;
   };
 
@@ -102,13 +101,13 @@ export function createAICreditHelpers(
     userId: string | undefined,
     generationType: string
   ): Promise<void> => {
-    const creditType = getCreditType(generationType);
-    await checker.deductCreditsAfterSuccess(userId, creditType);
+    const cost = getCost(generationType);
+    await checker.deductCreditsAfterSuccess(userId, cost);
   };
 
   return {
     checkCreditsForGeneration,
     deductCreditsForGeneration,
-    getCreditType,
+    getCost,
   };
 }

package/src/utils/creditChecker.ts

@@ -5,58 +5,50 @@
  * Generic - works with any generation type mapping.
  */
 
-import type { CreditType } from "../domain/entities/Credits";
 import type { CreditsRepository } from "../infrastructure/repositories/CreditsRepository";
 
 export interface CreditCheckResult {
   success: boolean;
   error?: string;
-  creditType?: CreditType;
 }
 
 export interface CreditCheckerConfig {
   repository: CreditsRepository;
-  getCreditType: (operationType: string) => CreditType;
   /**
    * Optional callback called after successful credit deduction.
    * Use this to invalidate TanStack Query cache or trigger UI updates.
    * @param userId - The user whose credits were deducted
-   * @param creditType - The type of credit that was deducted
+   * @param cost - The amount of credits deducted
    */
-  onCreditDeducted?: (userId: string, creditType: CreditType) => void;
+  onCreditDeducted?: (userId: string, cost: number) => void;
 }
 
 export const createCreditChecker = (config: CreditCheckerConfig) => {
-  const { repository, getCreditType, onCreditDeducted } = config;
+  const { repository, onCreditDeducted } = config;
 
   const checkCreditsAvailable = async (
     userId: string | undefined,
-    operationType: string
+    cost: number = 1
   ): Promise<CreditCheckResult> => {
     if (!userId) {
       return { success: false, error: "anonymous_user_blocked" };
     }
 
-    const creditType = getCreditType(operationType);
-    const hasCreditsAvailable = await repository.hasCredits(userId, creditType);
+    const hasCreditsAvailable = await repository.hasCredits(userId, cost);
 
     if (!hasCreditsAvailable) {
       return {
         success: false,
-        error:
-          creditType === "image"
-            ? "credits_exhausted_image"
-            : "credits_exhausted_text",
-        creditType,
+        error: "credits_exhausted",
       };
     }
 
-    return { success: true, creditType };
+    return { success: true };
   };
 
   const deductCreditsAfterSuccess = async (
     userId: string | undefined,
-    creditType: CreditType
+    cost: number = 1
   ): Promise<void> => {
     if (!userId) return;
 
@@ -64,10 +56,10 @@ export const createCreditChecker = (config: CreditCheckerConfig) => {
     let lastError: Error | null = null;
 
     for (let attempt = 0; attempt < maxRetries; attempt++) {
-      const result = await repository.deductCredit(userId, creditType);
+      const result = await repository.deductCredit(userId, cost);
       if (result.success) {
         // Notify subscribers that credits were deducted
-        onCreditDeducted?.(userId, creditType);
+        onCreditDeducted?.(userId, cost);
         return;
       }
       lastError = new Error(result.error?.message || "Deduction failed");
@@ -79,6 +71,7 @@ export const createCreditChecker = (config: CreditCheckerConfig) => {
     }
   };
 
+
   return {
     checkCreditsAvailable,
     deductCreditsAfterSuccess,

package/src/utils/creditMapper.ts

@@ -1,95 +1,36 @@
-/**
- * Credit Mapper
- * Maps subscription package types to credit amounts
- * Based on SUBSCRIPTION_GUIDE.md pricing strategy
- */
-
 import { detectPackageType, type SubscriptionPackageType } from "./packageTypeDetector";
-
-export interface CreditAllocation {
-  imageCredits: number;
-  textCredits: number;
-}
+import type { PackageAllocationMap } from "../domain/entities/Credits";
 
 /**
- * Standard credit allocations per package type
- * Based on profitability analysis and value ladder strategy
- *
- * Weekly:  6 images  - $2.99 (62% margin) - Trial users
- * Monthly: 25 images - $9.99 (60% margin) - Regular users
- * Yearly:  300 images - $79.99 (55% margin) - Best value (46% cheaper/image)
- */
-export const CREDIT_ALLOCATIONS: Record<
-  Exclude<SubscriptionPackageType, "unknown">,
-  CreditAllocation
-> = {
-  weekly: {
-    imageCredits: 6,
-    textCredits: 6,
-  },
-  monthly: {
-    imageCredits: 25,
-    textCredits: 25,
-  },
-  yearly: {
-    imageCredits: 300,
-    textCredits: 300,
-  },
-};
-
-/**
- * Get credit allocation for a package type
- * Returns null for unknown package types to prevent incorrect credit assignment
+ * Get credit allocation for a package type from provided allocations map
  */
 export function getCreditAllocation(
-  packageType: SubscriptionPackageType
-): CreditAllocation | null {
-  if (packageType === "unknown") return null;
-  return CREDIT_ALLOCATIONS[packageType];
-}
-
-/**
- * Get image credits for a package type
- */
-export function getImageCreditsForPackage(
-  packageType: SubscriptionPackageType
+  packageType: SubscriptionPackageType,
+  allocations?: PackageAllocationMap
 ): number | null {
-  const allocation = getCreditAllocation(packageType);
-  return allocation?.imageCredits ?? null;
-}
-
-/**
- * Get text credits for a package type
- */
-export function getTextCreditsForPackage(
-  packageType: SubscriptionPackageType
-): number | null {
-  const allocation = getCreditAllocation(packageType);
-  return allocation?.textCredits ?? null;
+  if (packageType === "unknown" || !allocations) return null;
+  return allocations[packageType]?.credits ?? null;
 }
 
 /**
  * Create credit amounts mapping for PaywallModal from RevenueCat packages
- * Maps product.identifier to credit amount
- *
- * @example
- * ```typescript
- * const creditAmounts = createCreditAmountsFromPackages(packages);
- * // { "futureus_weekly_2_99": 6, "futureus_monthly_9_99": 25, "futureus_yearly_79_99": 300 }
- * ```
+ * Maps product.identifier to credit amount using dynamic allocations
  */
 export function createCreditAmountsFromPackages(
-  packages: Array<{ product: { identifier: string } }>
+  packages: Array<{ product: { identifier: string } }>,
+  allocations?: PackageAllocationMap
 ): Record<string, number> {
   const result: Record<string, number> = {};
 
+  if (!allocations) return result;
+
   for (const pkg of packages) {
     const identifier = pkg?.product?.identifier;
 
     if (!identifier) continue;
 
     const packageType = detectPackageType(identifier);
-    const credits = getImageCreditsForPackage(packageType);
+    const credits = getCreditAllocation(packageType, allocations);
 
     if (credits !== null) {
       result[identifier] = credits;