@umituz/react-native-gamification 1.2.1 → 1.3.0

package/src/infrastructure/storage/GamificationStore.ts

@@ -1,363 +0,0 @@
-/**
- * Gamification Store - Unified State Management
- * 
- * Uses Zustand for state management with repository pattern
- * App-specific implementations can provide custom repository
- */
-
-import { create } from "zustand";
-import type { IGamificationRepository } from "../../domain/repositories/IGamificationRepository";
-import { storageGamificationRepository } from "../repositories/StorageGamificationRepository";
-import type { Achievement } from "../../domain/entities/Achievement";
-import type { PointBalance, PointTransaction } from "../../domain/entities/Point";
-import type { Level, LevelProgress } from "../../domain/entities/Level";
-import type { Streak } from "../../domain/entities/Streak";
-import type { Leaderboard, LeaderboardEntry, LeaderboardRanking } from "../../domain/entities/Leaderboard";
-import type { Reward, RewardClaim } from "../../domain/entities/Reward";
-import type { Progress, ProgressUpdate } from "../../domain/entities/Progress";
-
-interface GamificationStore {
-  // Repository
-  repository: IGamificationRepository;
-
-  // State
-  userId: string | null;
-  achievements: Achievement[];
-  pointBalance: PointBalance | null;
-  pointTransactions: PointTransaction[];
-  level: Level | null;
-  streaks: Streak[];
-  rewards: Reward[];
-  progress: Progress[];
-
-  // Loading states
-  isLoading: boolean;
-  isInitialized: boolean;
-
-  // Actions - Initialization
-  setUserId: (userId: string) => void;
-  setRepository: (repository: IGamificationRepository) => void;
-  initialize: (userId: string) => Promise<void>;
-
-  // Actions - Achievements
-  loadAchievements: () => Promise<void>;
-  updateAchievementProgress: (achievementId: string, progressIncrement: number) => Promise<void>;
-  unlockAchievement: (achievementId: string) => Promise<void>;
-
-  // Actions - Points
-  loadPointBalance: () => Promise<void>;
-  loadPointTransactions: (limit?: number) => Promise<void>;
-  addPoints: (
-    amount: number,
-    source: string,
-    sourceId?: string,
-    category?: string,
-    description?: string,
-  ) => Promise<void>;
-  deductPoints: (
-    amount: number,
-    source: string,
-    sourceId?: string,
-    description?: string,
-  ) => Promise<void>;
-
-  // Actions - Levels
-  loadLevel: () => Promise<void>;
-  addExperience: (amount: number, source?: string) => Promise<void>;
-
-  // Actions - Streaks
-  loadStreaks: () => Promise<void>;
-  updateStreakActivity: (type: string, activityDate: string) => Promise<void>;
-
-  // Actions - Rewards
-  loadRewards: () => Promise<void>;
-  claimReward: (rewardId: string) => Promise<RewardClaim | null>;
-
-  // Actions - Progress
-  loadProgress: (metric?: string) => Promise<void>;
-  updateProgress: (update: ProgressUpdate) => Promise<void>;
-}
-
-export const useGamificationStore = create<GamificationStore>((set, get) => ({
-  // Repository
-  repository: storageGamificationRepository,
-
-  // State
-  userId: null,
-  achievements: [],
-  pointBalance: null,
-  pointTransactions: [],
-  level: null,
-  streaks: [],
-  rewards: [],
-  progress: [],
-
-  // Loading states
-  isLoading: false,
-  isInitialized: false,
-
-  // Actions - Initialization
-  setUserId: (userId: string) => {
-    set({ userId });
-  },
-
-  setRepository: (repository: IGamificationRepository) => {
-    set({ repository });
-  },
-
-  initialize: async (userId: string) => {
-    set({ isLoading: true, userId });
-    const store = get();
-    try {
-      await Promise.all([
-        store.loadAchievements(),
-        store.loadPointBalance(),
-        store.loadLevel(),
-        store.loadStreaks(),
-        store.loadRewards(),
-        store.loadProgress(),
-      ]);
-      set({ isLoading: false, isInitialized: true });
-    } catch (error) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) console.error("Failed to initialize gamification:", error);
-      set({ isLoading: false, isInitialized: true });
-    }
-  },
-
-  // Actions - Achievements
-  loadAchievements: async () => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    set({ isLoading: true });
-    const result = await repository.loadAchievements(userId);
-    if (result.success) {
-      set({ achievements: result.data, isLoading: false });
-    } else {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) console.error("Failed to load achievements:", result.error);
-      set({ isLoading: false });
-    }
-  },
-
-  updateAchievementProgress: async (achievementId: string, progressIncrement: number) => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    
-    // Find existing achievement to get current progress
-    const existingAchievement = get().achievements.find((a) => a.id === achievementId);
-    if (!existingAchievement) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) console.warn(`Achievement ${achievementId} not found, cannot update progress`);
-      return;
-    }
-    
-    // Calculate new progress (add increment to current progress)
-    const currentProgress = existingAchievement.progress || 0;
-    const newProgress = Math.min(currentProgress + progressIncrement, existingAchievement.requirement);
-    
-    const result = await repository.updateAchievementProgress(userId, achievementId, newProgress);
-    if (result.success) {
-      const achievements = get().achievements.map((a) =>
-        a.id === achievementId ? result.data : a,
-      );
-      set({ achievements });
-      // Check if achievement should be unlocked
-      if (newProgress >= result.data.requirement && !result.data.unlocked) {
-        await get().unlockAchievement(achievementId);
-      }
-    }
-  },
-
-  unlockAchievement: async (achievementId: string) => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.unlockAchievement(userId, achievementId);
-    if (result.success) {
-      const achievements = get().achievements.map((a) =>
-        a.id === achievementId ? result.data : a,
-      );
-      set({ achievements });
-      // Award points if achievement has points
-      if (result.data.points) {
-        await get().addPoints(
-          result.data.points,
-          "achievement",
-          achievementId,
-          "achievement",
-          `Unlocked achievement: ${result.data.title}`,
-        );
-      }
-    }
-  },
-
-  // Actions - Points
-  loadPointBalance: async () => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.loadPointBalance(userId);
-    if (result.success) {
-      set({ pointBalance: result.data });
-    }
-  },
-
-  loadPointTransactions: async (limit?: number) => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.loadPointTransactions(userId, limit);
-    if (result.success) {
-      set({ pointTransactions: result.data });
-    }
-  },
-
-  addPoints: async (
-    amount: number,
-    source: string,
-    sourceId?: string,
-    category?: string,
-    description?: string,
-  ) => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.addPoints(userId, amount, source, sourceId, category, description);
-    if (result.success) {
-      await get().loadPointBalance();
-      await get().loadPointTransactions(10);
-    }
-  },
-
-  deductPoints: async (
-    amount: number,
-    source: string,
-    sourceId?: string,
-    description?: string,
-  ) => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.deductPoints(userId, amount, source, sourceId, description);
-    if (result.success) {
-      await get().loadPointBalance();
-      await get().loadPointTransactions(10);
-    }
-  },
-
-  // Actions - Levels
-  loadLevel: async () => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.loadLevel(userId);
-    if (result.success) {
-      set({ level: result.data });
-    }
-  },
-
-  addExperience: async (amount: number, source?: string) => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.addExperience(userId, amount, source);
-    if (result.success) {
-      await get().loadLevel();
-      // Check for level up
-      if (result.data.canLevelUp) {
-        // Award points for level up (optional)
-        await get().addPoints(
-          result.data.currentLevel * 10,
-          "level_up",
-          undefined,
-          "level",
-          `Leveled up to level ${result.data.currentLevel}`,
-        );
-      }
-    }
-  },
-
-  // Actions - Streaks
-  loadStreaks: async () => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.loadStreaks(userId);
-    if (result.success) {
-      set({ streaks: result.data });
-    }
-  },
-
-  updateStreakActivity: async (type: string, activityDate: string) => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.updateStreakActivity(userId, type, activityDate);
-    if (result.success) {
-      const streaks = get().streaks.map((s) => (s.id === result.data.id ? result.data : s));
-      const existingIndex = streaks.findIndex((s) => s.id === result.data.id);
-      if (existingIndex === -1) {
-        streaks.push(result.data);
-      }
-      set({ streaks });
-    }
-  },
-
-  // Actions - Rewards
-  loadRewards: async () => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.loadRewards(userId);
-    if (result.success) {
-      set({ rewards: result.data });
-    }
-  },
-
-  claimReward: async (rewardId: string): Promise<RewardClaim | null> => {
-    const { userId, repository } = get();
-    if (!userId) return null;
-    const reward = get().rewards.find((r) => r.id === rewardId);
-    if (reward?.pointsCost) {
-      const balance = get().pointBalance;
-      if (!balance || balance.total < reward.pointsCost) {
-        return null;
-      }
-      await get().deductPoints(
-        reward.pointsCost,
-        "reward_claim",
-        rewardId,
-        `Claimed reward: ${reward.title}`,
-      );
-    }
-    const result = await repository.claimReward(userId, rewardId);
-    if (result.success) {
-      await get().loadRewards();
-      return result.data;
-    }
-    return null;
-  },
-
-  // Actions - Progress
-  loadProgress: async (metric?: string) => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.loadProgress(userId, metric);
-    if (result.success) {
-      if (metric) {
-        const existing = get().progress.filter((p) => p.metric !== metric);
-        set({ progress: [...existing, ...result.data] });
-      } else {
-        set({ progress: result.data });
-      }
-    }
-  },
-
-  updateProgress: async (update: ProgressUpdate) => {
-    const { userId, repository } = get();
-    if (!userId) return;
-    const result = await repository.updateProgress(update);
-    if (result.success) {
-      const progress = get().progress.map((p) => (p.id === result.data.id ? result.data : p));
-      const existingIndex = progress.findIndex((p) => p.id === result.data.id);
-      if (existingIndex === -1) {
-        progress.push(result.data);
-      }
-      set({ progress });
-    }
-  },
-}));
-
-
-

package/src/presentation/hooks/useAchievements.ts

@@ -1,37 +0,0 @@
-/**
- * useAchievements Hook
- * 
- * Hook for achievement operations
- */
-
-import { useGamificationStore } from "../../infrastructure/storage/GamificationStore";
-import type { Achievement } from "../../domain/entities/Achievement";
-
-/**
- * Hook for achievement operations
- */
-export const useAchievements = () => {
-  const store = useGamificationStore();
-
-  return {
-    achievements: store.achievements,
-    loadAchievements: store.loadAchievements,
-    updateAchievementProgress: store.updateAchievementProgress,
-    unlockAchievement: store.unlockAchievement,
-    getAchievementById: (id: string): Achievement | undefined => {
-      return store.achievements.find((a) => a.id === id);
-    },
-    getAchievementsByCategory: (category: string): Achievement[] => {
-      return store.achievements.filter((a) => a.category === category);
-    },
-    getUnlockedAchievements: (): Achievement[] => {
-      return store.achievements.filter((a) => a.unlocked);
-    },
-    getLockedAchievements: (): Achievement[] => {
-      return store.achievements.filter((a) => !a.unlocked);
-    },
-  };
-};
-
-
-

package/src/presentation/hooks/useGamification.ts

@@ -1,93 +0,0 @@
-/**
- * useGamification Hook
- * 
- * Main hook for accessing gamification store
- */
-
-import { useEffect } from "react";
-import { useGamificationStore } from "../../infrastructure/storage/GamificationStore";
-import type { IGamificationRepository } from "../../domain/repositories/IGamificationRepository";
-
-/**
- * Main hook for gamification operations
- */
-export const useGamification = () => {
-  const store = useGamificationStore();
-
-  return {
-    // State
-    userId: store.userId,
-    achievements: store.achievements,
-    pointBalance: store.pointBalance,
-    pointTransactions: store.pointTransactions,
-    level: store.level,
-    streaks: store.streaks,
-    rewards: store.rewards,
-    progress: store.progress,
-    isLoading: store.isLoading,
-    isInitialized: store.isInitialized,
-
-    // Actions - Initialization
-    setUserId: store.setUserId,
-    setRepository: store.setRepository,
-    initialize: store.initialize,
-
-    // Actions - Achievements
-    loadAchievements: store.loadAchievements,
-    updateAchievementProgress: store.updateAchievementProgress,
-    unlockAchievement: store.unlockAchievement,
-
-    // Actions - Points
-    loadPointBalance: store.loadPointBalance,
-    loadPointTransactions: store.loadPointTransactions,
-    addPoints: store.addPoints,
-    deductPoints: store.deductPoints,
-
-    // Actions - Levels
-    loadLevel: store.loadLevel,
-    addExperience: store.addExperience,
-
-    // Actions - Streaks
-    loadStreaks: store.loadStreaks,
-    updateStreakActivity: store.updateStreakActivity,
-
-    // Actions - Rewards
-    loadRewards: store.loadRewards,
-    claimReward: store.claimReward,
-
-    // Actions - Progress
-    loadProgress: store.loadProgress,
-    updateProgress: store.updateProgress,
-  };
-};
-
-/**
- * Hook to initialize gamification on mount
- */
-export const useGamificationInitializer = (userId: string | null) => {
-  const { initialize, isInitialized } = useGamificationStore();
-
-  useEffect(() => {
-    if (userId && !isInitialized) {
-      initialize(userId);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [userId, isInitialized]);
-};
-
-/**
- * Hook to set custom repository
- */
-export const useGamificationRepository = (repository: IGamificationRepository | null) => {
-  const { setRepository } = useGamificationStore();
-
-  useEffect(() => {
-    if (repository) {
-      setRepository(repository);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [repository]);
-};
-
-
-

package/src/presentation/hooks/useLevel.ts

@@ -1,39 +0,0 @@
-/**
- * useLevel Hook
- * 
- * Hook for level operations
- */
-
-import { useGamificationStore } from "../../infrastructure/storage/GamificationStore";
-import type { Level, LevelProgress } from "../../domain/entities/Level";
-
-/**
- * Hook for level operations
- */
-export const useLevel = () => {
-  const store = useGamificationStore();
-
-  return {
-    level: store.level,
-    loadLevel: store.loadLevel,
-    addExperience: store.addExperience,
-    getCurrentLevel: (): number => {
-      return store.level?.currentLevel || 1;
-    },
-    getCurrentExperience: (): number => {
-      return store.level?.currentExperience || 0;
-    },
-    getTotalExperience: (): number => {
-      return store.level?.totalExperience || 0;
-    },
-    getExperienceToNextLevel: (): number => {
-      return store.level?.experienceToNextLevel || 100;
-    },
-    getLevelProgress: (): number => {
-      return store.level?.levelProgress || 0;
-    },
-  };
-};
-
-
-

package/src/presentation/hooks/usePoints.ts

@@ -1,36 +0,0 @@
-/**
- * usePoints Hook
- * 
- * Hook for points operations
- */
-
-import { useGamificationStore } from "../../infrastructure/storage/GamificationStore";
-import type { PointBalance, PointTransaction } from "../../domain/entities/Point";
-
-/**
- * Hook for points operations
- */
-export const usePoints = () => {
-  const store = useGamificationStore();
-
-  return {
-    pointBalance: store.pointBalance,
-    pointTransactions: store.pointTransactions,
-    loadPointBalance: store.loadPointBalance,
-    loadPointTransactions: store.loadPointTransactions,
-    addPoints: store.addPoints,
-    deductPoints: store.deductPoints,
-    getTotalPoints: (): number => {
-      return store.pointBalance?.total || 0;
-    },
-    getPointsByCategory: (category: string): number => {
-      return store.pointBalance?.byCategory[category] || 0;
-    },
-    getRecentTransactions: (limit: number = 10): PointTransaction[] => {
-      return store.pointTransactions.slice(0, limit);
-    },
-  };
-};
-
-
-

package/src/presentation/hooks/useProgress.ts

@@ -1,33 +0,0 @@
-/**
- * useProgress Hook
- * 
- * Hook for progress tracking operations
- */
-
-import { useGamificationStore } from "../../infrastructure/storage/GamificationStore";
-import type { Progress } from "../../domain/entities/Progress";
-
-/**
- * Hook for progress tracking operations
- */
-export const useProgress = () => {
-  const store = useGamificationStore();
-
-  return {
-    progress: store.progress,
-    loadProgress: store.loadProgress,
-    updateProgress: store.updateProgress,
-    getProgressByMetric: (metric: string): Progress | undefined => {
-      return store.progress.find((p) => p.metric === metric);
-    },
-    getProgressByCategory: (category: string): Progress[] => {
-      return store.progress.filter((p) => p.category === category);
-    },
-    getProgressByPeriod: (period: "daily" | "weekly" | "monthly" | "all-time"): Progress[] => {
-      return store.progress.filter((p) => p.period === period);
-    },
-  };
-};
-
-
-

package/src/presentation/hooks/useRewards.ts

@@ -1,43 +0,0 @@
-/**
- * useRewards Hook
- * 
- * Hook for reward operations
- */
-
-import { useGamificationStore } from "../../infrastructure/storage/GamificationStore";
-import type { Reward } from "../../domain/entities/Reward";
-
-/**
- * Hook for reward operations
- */
-export const useRewards = () => {
-  const store = useGamificationStore();
-
-  return {
-    rewards: store.rewards,
-    loadRewards: store.loadRewards,
-    claimReward: store.claimReward,
-    getRewardById: (id: string): Reward | undefined => {
-      return store.rewards.find((r) => r.id === id);
-    },
-    getUnlockedRewards: (): Reward[] => {
-      return store.rewards.filter((r) => r.unlocked && !r.claimed);
-    },
-    getClaimedRewards: (): Reward[] => {
-      return store.rewards.filter((r) => r.claimed);
-    },
-    getAvailableRewards: (): Reward[] => {
-      const balance = store.pointBalance?.total || 0;
-      const level = store.level?.currentLevel || 1;
-      return store.rewards.filter(
-        (r) =>
-          !r.claimed &&
-          (!r.pointsCost || r.pointsCost <= balance) &&
-          (!r.levelRequired || r.levelRequired <= level),
-      );
-    },
-  };
-};
-
-
-

package/src/presentation/hooks/useStreaks.ts

@@ -1,36 +0,0 @@
-/**
- * useStreaks Hook
- * 
- * Hook for streak operations
- */
-
-import { useGamificationStore } from "../../infrastructure/storage/GamificationStore";
-import type { Streak } from "../../domain/entities/Streak";
-
-/**
- * Hook for streak operations
- */
-export const useStreaks = () => {
-  const store = useGamificationStore();
-
-  return {
-    streaks: store.streaks,
-    loadStreaks: store.loadStreaks,
-    updateStreakActivity: store.updateStreakActivity,
-    getStreakByType: (type: string): Streak | undefined => {
-      return store.streaks.find((s) => s.type === type);
-    },
-    getActiveStreaks: (): Streak[] => {
-      return store.streaks.filter((s) => s.isActive);
-    },
-    getLongestStreak: (type?: string): number => {
-      const streaks = type
-        ? store.streaks.filter((s) => s.type === type)
-        : store.streaks;
-      return Math.max(...streaks.map((s) => s.longestStreak), 0);
-    },
-  };
-};
-
-
-