@umituz/react-native-settings 4.17.27 → 4.17.31

package/src/domains/appearance/infrastructure/stores/appearanceStore.ts

@@ -1,132 +0,0 @@
-/**
- * Appearance Store
- *
- * Zustand store for appearance state management
- * Single Responsibility: Pure state management only
- */
-
-import { create } from "zustand";
-import type { AppearanceSettings, AppearanceState } from "../../types";
-
-interface AppearanceStoreActions {
-  // Pure state mutations only
-  setSettings: (settings: AppearanceSettings) => void;
-  setInitialized: (initialized: boolean) => void;
-  updateThemeMode: (mode: AppearanceSettings["themeMode"]) => void;
-  updateCustomColors: (colors: AppearanceSettings["customColors"]) => void;
-  resetState: () => void;
-}
-
-type AppearanceStore = AppearanceState & AppearanceStoreActions;
-
-const DEFAULT_SETTINGS: AppearanceSettings = {
-  themeMode: "dark", // Use dark mode as default
-};
-
-export const useAppearanceStore = create<AppearanceStore>((set, get) => ({
-  settings: DEFAULT_SETTINGS,
-  isInitialized: false,
-
-  // Pure state mutations with performance optimizations
-  setSettings: (settings: AppearanceSettings) => {
-    // Prevent unnecessary updates if settings are the same
-    const currentSettings = get().settings;
-    if (JSON.stringify(currentSettings) === JSON.stringify(settings)) {
-      if (__DEV__) {
-        console.log("[AppearanceStore] Skipping settings update - no changes");
-      }
-      return;
-    }
-
-    if (__DEV__) {
-      console.log("[AppearanceStore] Setting appearance settings:", settings);
-    }
-    set({ settings });
-  },
-
-  setInitialized: (initialized: boolean) => {
-    // Prevent unnecessary updates if state is the same
-    const currentInitialized = get().isInitialized;
-    if (currentInitialized === initialized) {
-      if (__DEV__) {
-        console.log("[AppearanceStore] Skipping initialized update - no change");
-      }
-      return;
-    }
-
-    if (__DEV__) {
-      console.log("[AppearanceStore] Setting initialized state:", initialized);
-    }
-    set({ isInitialized: initialized });
-  },
-
-  updateThemeMode: (mode: AppearanceSettings["themeMode"]) => {
-    const currentSettings = get().settings;
-    
-    // Prevent unnecessary updates if mode is the same
-    if (currentSettings.themeMode === mode) {
-      if (__DEV__) {
-        console.log("[AppearanceStore] Skipping theme mode update - no change");
-      }
-      return;
-    }
-
-    const newSettings: AppearanceSettings = {
-      ...currentSettings,
-      themeMode: mode,
-    };
-    
-    if (__DEV__) {
-      console.log("[AppearanceStore] Updating theme mode:", mode);
-    }
-    
-    set({ settings: newSettings });
-  },
-
-  updateCustomColors: (colors: AppearanceSettings["customColors"]) => {
-    const currentSettings = get().settings;
-    
-    // Prevent unnecessary updates if colors are the same
-    if (JSON.stringify(currentSettings.customColors) === JSON.stringify(colors)) {
-      if (__DEV__) {
-        console.log("[AppearanceStore] Skipping custom colors update - no changes");
-      }
-      return;
-    }
-
-    const newSettings: AppearanceSettings = {
-      ...currentSettings,
-      customColors: colors,
-    };
-    
-    if (__DEV__) {
-      console.log("[AppearanceStore] Updating custom colors:", colors);
-    }
-    
-    set({ settings: newSettings });
-  },
-
-  resetState: () => {
-    const currentState = get();
-    
-    // Prevent unnecessary reset if already at default
-    if (
-      currentState.isInitialized === false &&
-      JSON.stringify(currentState.settings) === JSON.stringify(DEFAULT_SETTINGS)
-    ) {
-      if (__DEV__) {
-        console.log("[AppearanceStore] Skipping reset - already at default state");
-      }
-      return;
-    }
-
-    if (__DEV__) {
-      console.log("[AppearanceStore] Resetting to default state");
-    }
-    
-    set({
-      settings: DEFAULT_SETTINGS,
-      isInitialized: false,
-    });
-  },
-}));

package/src/infrastructure/storage/SettingsStore.ts

@@ -1,189 +0,0 @@
-/**
- * Settings Store - Zustand State Management
- *
- * Global settings state for app preferences
- * Manages theme, language, notifications, and privacy settings
- *
- * DDD ARCHITECTURE: Uses @umituz/react-native-storage for all storage operations
- * - Type-safe storage with StorageKey enum
- * - Result pattern for error handling
- * - Single source of truth for all storage
- */
-
-import { create } from 'zustand';
-import { storageRepository, StorageKey, createUserKey, unwrap } from '@umituz/react-native-storage';
-import type { UserSettings } from '../../domain/repositories/ISettingsRepository';
-
-interface SettingsStore {
-  // State
-  settings: UserSettings | null;
-  loading: boolean;
-  error: string | null;
-
-  // Actions
-  loadSettings: (userId: string) => Promise<void>;
-  updateSettings: (updates: Partial<UserSettings>) => Promise<void>;
-  resetSettings: (userId: string) => Promise<void>;
-  clearError: () => void;
-}
-
-const DEFAULT_OFFLINE_USER_ID = 'offline_user';
-
-const DEFAULT_SETTINGS_CACHE = new Map<string, UserSettings>();
-
-const getDefaultSettings = (userId: string): UserSettings => {
-  if (DEFAULT_SETTINGS_CACHE.has(userId)) {
-    return DEFAULT_SETTINGS_CACHE.get(userId)!;
-  }
-
-  const settings = {
-    userId,
-    theme: 'auto' as const,
-    language: 'en-US',
-    notificationsEnabled: true,
-    emailNotifications: true,
-    pushNotifications: true,
-    soundEnabled: true,
-    vibrationEnabled: true,
-    privacyMode: false,
-    disclaimerAccepted: false,
-    updatedAt: new Date(),
-  };
-
-  DEFAULT_SETTINGS_CACHE.set(userId, settings);
-  return settings;
-};
-
-export const useSettingsStore = create<SettingsStore>((set, get) => ({
-  settings: null,
-  loading: false,
-  error: null,
-
-  loadSettings: async (userId: string) => {
-    if (__DEV__) {
-      console.log('SettingsStore: Loading settings for user:', userId);
-    }
-
-    set({ loading: true, error: null });
-
-    try {
-      const defaultSettings = getDefaultSettings(userId);
-      const storageKey = createUserKey(StorageKey.USER_PREFERENCES, userId);
-
-      // ✅ DRY: Storage domain handles JSON parse, error handling
-      const result = await storageRepository.getItem<UserSettings>(storageKey, defaultSettings);
-      const data = unwrap(result, defaultSettings);
-
-      // ✅ CLEAN CODE: Auto-save defaults if not exists
-      if (!result.success) {
-        await storageRepository.setItem(storageKey, defaultSettings);
-      }
-
-      set({
-        settings: data,
-        loading: false,
-        error: null,
-      });
-
-      if (__DEV__) {
-        console.log('SettingsStore: Settings loaded successfully');
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error('SettingsStore: Failed to load settings:', error);
-      }
-      set({ loading: false, error: 'Failed to load settings' });
-    }
-  },
-
-  updateSettings: async (updates: Partial<UserSettings>) => {
-    if (__DEV__) {
-      console.log('SettingsStore: Updating settings with:', updates);
-    }
-
-    const { settings } = get();
-
-    // ✅ CLEAN CODE: Auto-initialize if settings not loaded
-    if (!settings) {
-      await get().loadSettings(DEFAULT_OFFLINE_USER_ID);
-    }
-
-    // ✅ DEFENSIVE: Verify settings loaded successfully
-    const currentSettings = get().settings;
-    if (!currentSettings) {
-      const errorMsg = 'Failed to initialize settings';
-      if (__DEV__) {
-        console.error('SettingsStore:', errorMsg);
-      }
-      set({ error: errorMsg });
-      return;
-    }
-
-    set({ loading: true, error: null });
-
-    try {
-      const updatedSettings: UserSettings = {
-        ...currentSettings,
-        ...updates,
-        updatedAt: new Date(),
-      };
-
-      const storageKey = createUserKey(StorageKey.USER_PREFERENCES, currentSettings.userId);
-
-      // ✅ DRY: Storage domain replaces JSON.stringify + AsyncStorage + try/catch
-      const result = await storageRepository.setItem(storageKey, updatedSettings);
-
-      set({
-        settings: result.success ? updatedSettings : currentSettings,
-        loading: false,
-        error: null,
-      });
-
-      if (__DEV__) {
-        console.log('SettingsStore: Settings updated successfully');
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error('SettingsStore: Failed to update settings:', error);
-      }
-      set({ loading: false, error: 'Failed to update settings' });
-    }
-  },
-
-  resetSettings: async (userId: string) => {
-    set({ loading: true, error: null });
-
-    const defaultSettings = getDefaultSettings(userId);
-    const storageKey = createUserKey(StorageKey.USER_PREFERENCES, userId);
-
-    // ✅ DRY: Storage domain replaces JSON.stringify + AsyncStorage + try/catch
-    const result = await storageRepository.setItem(storageKey, defaultSettings);
-
-    set({
-      settings: result.success ? defaultSettings : get().settings,
-      loading: false,
-      error: null,
-    });
-  },
-
-  clearError: () => set({ error: null }),
-}));
-
-/**
- * Hook for accessing settings state
- */
-export const useSettings = () => {
-  const { settings, loading, error, loadSettings, updateSettings, resetSettings, clearError } =
-    useSettingsStore();
-
-  return {
-    settings,
-    loading,
-    error,
-    loadSettings,
-    updateSettings,
-    resetSettings,
-    clearError,
-  };
-};
-

package/src/infrastructure/storage/__tests__/SettingsStore.test.tsx

@@ -1,302 +0,0 @@
-/**
- * Tests for SettingsStore and useSettings Hook
- */
-
-import { renderHook, act } from '@testing-library/react-hooks';
-import { useSettings, useSettingsStore } from '../SettingsStore';
-import type { UserSettings } from '../../../domain/repositories/ISettingsRepository';
-
-// Mock storage repository
-const mockStorageRepository = {
-  getItem: jest.fn(),
-  setItem: jest.fn(),
-  removeItem: jest.fn(),
-  clear: jest.fn(),
-};
-
-jest.mock('@umituz/react-native-storage', () => ({
-  storageRepository: mockStorageRepository,
-  StorageKey: {
-    SETTINGS: 'settings',
-  },
-  createUserKey: (key: string, userId: string) => `${key}_${userId}`,
-  unwrap: (result: any, defaultValue: any) => result.success ? result.data : defaultValue,
-}));
-
-describe('SettingsStore', () => {
-  const mockUserId = 'test-user-123';
-  const mockSettings: UserSettings = {
-    userId: mockUserId,
-    theme: 'dark',
-    language: 'en-US',
-    notificationsEnabled: true,
-    emailNotifications: false,
-    pushNotifications: true,
-    soundEnabled: true,
-    vibrationEnabled: false,
-    privacyMode: false,
-    updatedAt: new Date('2023-01-01'),
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('loadSettings', () => {
-    it('loads settings successfully from storage', async () => {
-      mockStorageRepository.getItem.mockResolvedValue({
-        success: true,
-        data: mockSettings,
-      });
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      await act(async () => {
-        await result.current.loadSettings(mockUserId);
-      });
-
-      expect(result.current.settings).toEqual(mockSettings);
-      expect(result.current.loading).toBe(false);
-      expect(result.current.error).toBeNull();
-      expect(mockStorageRepository.getItem).toHaveBeenCalledWith(
-        `settings_${mockUserId}`,
-        expect.any(Object)
-      );
-    });
-
-    it('uses default settings when storage fails', async () => {
-      mockStorageRepository.getItem.mockResolvedValue({
-        success: false,
-        error: 'Storage error',
-      });
-      mockStorageRepository.setItem.mockResolvedValue({
-        success: true,
-      });
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      await act(async () => {
-        await result.current.loadSettings(mockUserId);
-      });
-
-      expect(result.current.settings).toBeDefined();
-      expect(result.current.settings?.userId).toBe(mockUserId);
-      expect(result.current.settings?.theme).toBe('auto');
-      expect(result.current.loading).toBe(false);
-      expect(result.current.error).toBeNull();
-      expect(mockStorageRepository.setItem).toHaveBeenCalled();
-    });
-
-    it('handles loading state correctly', async () => {
-      mockStorageRepository.getItem.mockImplementation(() => new Promise(resolve => 
-        setTimeout(() => resolve({ success: true, data: mockSettings }), 100)
-      ));
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      act(() => {
-        result.current.loadSettings(mockUserId);
-      });
-
-      expect(result.current.loading).toBe(true);
-
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 150));
-      });
-
-      expect(result.current.loading).toBe(false);
-      expect(result.current.settings).toEqual(mockSettings);
-    });
-
-    it('handles storage exceptions', async () => {
-      mockStorageRepository.getItem.mockRejectedValue(new Error('Storage exception'));
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      await act(async () => {
-        await result.current.loadSettings(mockUserId);
-      });
-
-      expect(result.current.loading).toBe(false);
-      expect(result.current.error).toBe('Failed to load settings');
-      expect(result.current.settings).toBeNull();
-    });
-  });
-
-  describe('updateSettings', () => {
-    it('updates settings successfully', async () => {
-      // First load settings
-      mockStorageRepository.getItem.mockResolvedValue({
-        success: true,
-        data: mockSettings,
-      });
-      mockStorageRepository.setItem.mockResolvedValue({
-        success: true,
-      });
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      await act(async () => {
-        await result.current.loadSettings(mockUserId);
-      });
-
-      // Then update settings
-      const updates = { theme: 'light' as const, notificationsEnabled: false };
-
-      await act(async () => {
-        await result.current.updateSettings(updates);
-      });
-
-      expect(result.current.settings?.theme).toBe('light');
-      expect(result.current.settings?.notificationsEnabled).toBe(false);
-      expect(result.current.settings?.updatedAt).toBeInstanceOf(Date);
-      expect(mockStorageRepository.setItem).toHaveBeenCalledWith(
-        `settings_${mockUserId}`,
-        expect.objectContaining({
-          theme: 'light',
-          notificationsEnabled: false,
-        })
-      );
-    });
-
-    it('auto-initializes settings when not loaded', async () => {
-      mockStorageRepository.getItem
-        .mockResolvedValueOnce({ success: false, error: 'Not found' })
-        .mockResolvedValueOnce({ success: true, data: expect.any(Object) });
-      mockStorageRepository.setItem.mockResolvedValue({ success: true });
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      await act(async () => {
-        await result.current.updateSettings({ theme: 'light' as const });
-      });
-
-      expect(result.current.settings).toBeDefined();
-      expect(result.current.settings?.theme).toBe('light');
-    });
-
-    it('handles update failures gracefully', async () => {
-      mockStorageRepository.getItem.mockResolvedValue({
-        success: true,
-        data: mockSettings,
-      });
-      mockStorageRepository.setItem.mockResolvedValue({
-        success: false,
-        error: 'Update failed',
-      });
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      await act(async () => {
-        await result.current.loadSettings(mockUserId);
-      });
-
-      const originalSettings = result.current.settings;
-
-      await act(async () => {
-        await result.current.updateSettings({ theme: 'light' as const });
-      });
-
-      // Settings should remain unchanged on failure
-      expect(result.current.settings).toEqual(originalSettings);
-      expect(result.current.loading).toBe(false);
-    });
-
-    it('handles update exceptions', async () => {
-      mockStorageRepository.getItem.mockResolvedValue({
-        success: true,
-        data: mockSettings,
-      });
-      mockStorageRepository.setItem.mockRejectedValue(new Error('Update exception'));
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      await act(async () => {
-        await result.current.loadSettings(mockUserId);
-      });
-
-      await act(async () => {
-        await result.current.updateSettings({ theme: 'light' as const });
-      });
-
-      expect(result.current.loading).toBe(false);
-      expect(result.current.error).toBe('Failed to update settings');
-    });
-  });
-
-  describe('resetSettings', () => {
-    it('resets settings to defaults', async () => {
-      mockStorageRepository.getItem.mockResolvedValue({
-        success: true,
-        data: mockSettings,
-      });
-      mockStorageRepository.setItem.mockResolvedValue({
-        success: true,
-      });
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      await act(async () => {
-        await result.current.loadSettings(mockUserId);
-      });
-
-      await act(async () => {
-        await result.current.resetSettings(mockUserId);
-      });
-
-      expect(result.current.settings?.theme).toBe('auto');
-      expect(result.current.settings?.language).toBe('en-US');
-      expect(result.current.settings?.notificationsEnabled).toBe(true);
-      expect(mockStorageRepository.setItem).toHaveBeenCalledWith(
-        `settings_${mockUserId}`,
-        expect.objectContaining({
-          theme: 'auto',
-          language: 'en-US',
-        })
-      );
-    });
-  });
-
-  describe('clearError', () => {
-    it('clears error state', async () => {
-      mockStorageRepository.getItem.mockRejectedValue(new Error('Test error'));
-
-      const { result } = renderHook(() => useSettingsStore());
-
-      await act(async () => {
-        await result.current.loadSettings(mockUserId);
-      });
-
-      expect(result.current.error).toBe('Failed to load settings');
-
-      act(() => {
-        result.current.clearError();
-      });
-
-      expect(result.current.error).toBeNull();
-    });
-  });
-});
-
-describe('useSettings Hook', () => {
-  it('provides all store methods and state', () => {
-    const { result } = renderHook(() => useSettings());
-
-    expect(result.current).toHaveProperty('settings');
-    expect(result.current).toHaveProperty('loading');
-    expect(result.current).toHaveProperty('error');
-    expect(result.current).toHaveProperty('loadSettings');
-    expect(result.current).toHaveProperty('updateSettings');
-    expect(result.current).toHaveProperty('resetSettings');
-    expect(result.current).toHaveProperty('clearError');
-  });
-
-  it('is a thin wrapper around useSettingsStore', () => {
-    const storeResult = renderHook(() => useSettingsStore()).result;
-    const hookResult = renderHook(() => useSettings()).result;
-
-    expect(Object.keys(storeResult.current)).toEqual(
-      expect.arrayContaining(Object.keys(hookResult.current))
-    );
-  });
-});

package/src/presentation/components/CloudSyncSetting.tsx

@@ -1,58 +0,0 @@
-/**
- * Cloud Sync Setting Component
- * Single Responsibility: Display cloud sync setting item
- */
-
-import React, { useCallback } from "react";
-import { SettingItem } from "./SettingItem";
-import type { SettingItemProps } from "./SettingItem";
-
-export interface CloudSyncSettingProps {
-  title?: string;
-  description?: string;
-  isSyncing?: boolean;
-  lastSynced?: Date | null;
-  onPress?: () => void;
-  iconColor?: string;
-  titleColor?: string;
-}
-
-export const CloudSyncSetting: React.FC<CloudSyncSettingProps> = ({
-  title,
-  description,
-  isSyncing = false,
-  lastSynced,
-  onPress,
-  iconColor,
-  titleColor,
-}) => {
-  const formatLastSynced = useCallback((date: Date | null | undefined): string => {
-    if (!date) return "never_synced";
-    const now = new Date();
-    const diff = now.getTime() - date.getTime();
-    const minutes = Math.floor(diff / 60000);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
-
-    if (minutes < 1) return "just_now";
-    if (minutes < 60) return `${minutes}m_ago`;
-    if (hours < 24) return `${hours}h_ago`;
-    if (days < 7) return `${days}d_ago`;
-    return date.toLocaleDateString();
-  }, []);
-
-  const displayDescription = description || (isSyncing ? "syncing" : lastSynced ? `last_synced_${formatLastSynced(lastSynced)}` : "sync_to_cloud");
-
-  return (
-    <SettingItem
-      icon="cloud-outline"
-      title={title || "cloud_sync"}
-      value={displayDescription}
-      onPress={onPress}
-      iconColor={iconColor}
-      titleColor={titleColor}
-      disabled={isSyncing}
-    />
-  );
-};
-