@umituz/react-native-settings 4.17.26 → 4.17.30

package/src/domains/appearance/infrastructure/services/appearanceService.ts

@@ -1,301 +0,0 @@
-/**
- * Appearance Service
- *
- * Business logic for appearance management
- * Single Responsibility: Business logic only, no presentation logic
- */
-
-import { AppearanceStorage } from "../storage/appearanceStorage";
-import { useAppearanceStore } from "../stores/appearanceStore";
-import {
-  useTheme,
-  useDesignSystemTheme,
-  type ThemeMode,
-  type CustomThemeColors,
-} from "@umituz/react-native-design-system";
-import { getSystemTheme } from "./systemThemeDetection";
-import { validateAppearanceSettings } from "./validation";
-import type { AppearanceSettings } from "../../types";
-
-export class AppearanceService {
-  private readonly DEFAULT_THEME_MODE: ThemeMode = "light"; // Use system preference as default
-  private _isInitialized = false;
-  private initPromise: Promise<void> | null = null;
-
-  /**
-   * Initialize appearance settings
-   * Business logic: Coordinate initialization process
-   */
-  async initialize(): Promise<void> {
-    // Prevent multiple initializations
-    if (this._isInitialized || this.initPromise) {
-      return this.initPromise || Promise.resolve();
-    }
-
-    this.initPromise = this._performInitialization();
-    return this.initPromise;
-  }
-
-  private async _performInitialization(): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Initializing appearance settings");
-      }
-
-      const savedSettings = await AppearanceStorage.getSettings();
-
-      if (savedSettings) {
-        // Load saved settings
-        useAppearanceStore.getState().setSettings(savedSettings);
-        useAppearanceStore.getState().setInitialized(true);
-
-        // Sync with design system theme
-        await this.syncWithDesignSystem(savedSettings);
-      } else {
-        // Use system theme as default, fallback to light
-        const systemTheme = getSystemTheme();
-        const defaultSettings: AppearanceSettings = {
-          themeMode: systemTheme || this.DEFAULT_THEME_MODE,
-        };
-
-        useAppearanceStore.getState().setSettings(defaultSettings);
-        useAppearanceStore.getState().setInitialized(true);
-
-        // Sync with design system theme
-        await this.syncWithDesignSystem(defaultSettings);
-      }
-
-      this._isInitialized = true;
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Initialization failed:", error);
-      }
-
-      // Fallback to system theme or light mode on error
-      const systemTheme = getSystemTheme();
-      const fallbackSettings: AppearanceSettings = {
-        themeMode: systemTheme || this.DEFAULT_THEME_MODE,
-      };
-
-      useAppearanceStore.getState().setSettings(fallbackSettings);
-      useAppearanceStore.getState().setInitialized(true);
-
-      await this.syncWithDesignSystem(fallbackSettings);
-      this._isInitialized = true;
-    } finally {
-      this.initPromise = null;
-    }
-  }
-
-  /**
-   * Get current theme mode
-   * Business logic: Provide theme mode data
-   */
-  getThemeMode(): ThemeMode {
-    return useAppearanceStore.getState().settings.themeMode;
-  }
-
-  /**
-   * Set theme mode
-   * Business logic: Validate and apply theme mode
-   */
-  async setThemeMode(mode: ThemeMode): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Setting theme mode:", mode);
-      }
-
-      // Validate theme mode
-      if (!mode || (mode !== 'light' && mode !== 'dark')) {
-        throw new Error(`Invalid theme mode: ${mode}`);
-      }
-
-      const currentSettings = useAppearanceStore.getState().settings;
-      const newSettings: AppearanceSettings = {
-        ...currentSettings,
-        themeMode: mode,
-      };
-
-      // Update store
-      useAppearanceStore.getState().updateThemeMode(mode);
-
-      // Persist to storage
-      await AppearanceStorage.setSettings(newSettings);
-
-      // Sync with design system
-      await this.syncWithDesignSystem(newSettings);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to set theme mode:", errorMessage);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Toggle theme mode
-   * Business logic: Toggle between light and dark
-   */
-  async toggleTheme(): Promise<void> {
-    try {
-      const currentMode = this.getThemeMode();
-      const newMode: ThemeMode = 
-        currentMode === "light" ? "dark" : "light";
-      
-      await this.setThemeMode(newMode);
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to toggle theme:", error);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Get custom colors
-   * Business logic: Provide custom colors data
-   */
-  getCustomColors(): CustomThemeColors | undefined {
-    return useAppearanceStore.getState().settings.customColors;
-  }
-
-  /**
-   * Set custom colors
-   * Business logic: Validate and apply custom colors
-   */
-  async setCustomColors(colors: CustomThemeColors): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Setting custom colors:", colors);
-      }
-
-      // Validate custom colors
-      const validation = validateAppearanceSettings({ customColors: colors });
-      if (!validation.isValid) {
-        throw new Error(`Invalid custom colors: ${validation.errors.join(', ')}`);
-      }
-
-      const currentSettings = useAppearanceStore.getState().settings;
-      const newSettings: AppearanceSettings = {
-        ...currentSettings,
-        customColors: {
-          ...currentSettings.customColors,
-          ...colors,
-        },
-      };
-
-      // Update store
-      useAppearanceStore.getState().updateCustomColors(newSettings.customColors);
-
-      // Persist to storage
-      await AppearanceStorage.setSettings(newSettings);
-
-      // Sync with design system
-      await this.syncWithDesignSystem(newSettings);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to set custom colors:", errorMessage);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Reset custom colors to defaults
-   * Business logic: Reset custom colors
-   */
-  async resetCustomColors(): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Resetting custom colors");
-      }
-
-      const currentSettings = useAppearanceStore.getState().settings;
-      const newSettings: AppearanceSettings = {
-        ...currentSettings,
-        customColors: undefined,
-      };
-
-      // Update store
-      useAppearanceStore.getState().updateCustomColors(undefined);
-
-      // Persist to storage
-      await AppearanceStorage.setSettings(newSettings);
-
-      // Sync with design System
-      await this.syncWithDesignSystem(newSettings);
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to reset custom colors:", error);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Reset all appearance settings
-   * Business logic: Reset all settings
-   */
-  async reset(): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Resetting all appearance settings");
-      }
-
-      // Clear storage
-      await AppearanceStorage.clear();
-
-      // Reset store to defaults
-      useAppearanceStore.getState().resetState();
-
-      // Reset design system theme to system preference
-      const systemTheme = getSystemTheme();
-      const defaultSettings: AppearanceSettings = {
-        themeMode: systemTheme || this.DEFAULT_THEME_MODE,
-      };
-
-      await this.syncWithDesignSystem(defaultSettings);
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to reset appearance:", error);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Check if appearance is initialized
-   * Business logic: Provide initialization status
-   */
-  isInitialized(): boolean {
-    return useAppearanceStore.getState().isInitialized;
-  }
-
-  /**
-   * Sync appearance settings with design system
-   * Private helper method
-   */
-  private async syncWithDesignSystem(settings: AppearanceSettings): Promise<void> {
-    try {
-      // Sync theme mode
-      useTheme.getState().setThemeMode(settings.themeMode);
-      useDesignSystemTheme.getState().setThemeMode(settings.themeMode);
-
-      // Sync custom colors
-      useDesignSystemTheme.getState().setCustomColors(settings.customColors);
-
-      if (__DEV__) {
-        console.log("[AppearanceService] Synced with design system:", settings);
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to sync with design system:", error);
-      }
-      throw error;
-    }
-  }
-}
-
-export const appearanceService = new AppearanceService();

package/src/domains/appearance/infrastructure/storage/appearanceStorage.ts

@@ -1,120 +0,0 @@
-/**
- * Appearance Storage Service
- *
- * Handles persistence of appearance settings using AsyncStorage
- * Single Responsibility: Pure storage operations only
- */
-
-import { storageRepository, unwrap } from "@umituz/react-native-storage";
-import type { ThemeMode } from "@umituz/react-native-design-system";
-import type { AppearanceSettings } from "../../types";
-
-const STORAGE_KEYS = {
-  APPEARANCE_SETTINGS: "@appearance_settings",
-} as const;
-
-const DEFAULT_SETTINGS: AppearanceSettings = {
-  themeMode: "dark",
-};
-
-export class AppearanceStorage {
-  /**
-   * Get saved appearance settings
-   * Pure storage operation - no business logic
-   */
-  static async getSettings(): Promise<AppearanceSettings | null> {
-    try {
-      const result = await storageRepository.getItem<AppearanceSettings>(
-        STORAGE_KEYS.APPEARANCE_SETTINGS,
-        DEFAULT_SETTINGS,
-      );
-      const data = unwrap(result, DEFAULT_SETTINGS);
-      return data;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Save appearance settings
-   * Pure storage operation - no business logic
-   */
-  static async setSettings(settings: AppearanceSettings): Promise<void> {
-    const result = await storageRepository.setItem(
-      STORAGE_KEYS.APPEARANCE_SETTINGS,
-      settings,
-    );
-    if (!result.success) {
-      throw new Error("Failed to save appearance settings");
-    }
-  }
-
-  /**
-   * Get saved theme mode
-   * Pure storage operation - no business logic
-   */
-  static async getThemeMode(): Promise<ThemeMode | null> {
-    try {
-      const settings = await this.getSettings();
-      return settings?.themeMode || null;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Save theme mode
-   * Pure storage operation - no business logic
-   */
-  static async setThemeMode(themeMode: ThemeMode): Promise<void> {
-    const currentSettings = (await this.getSettings()) || {
-      themeMode: "dark",
-    };
-    await this.setSettings({
-      ...currentSettings,
-      themeMode,
-    });
-  }
-
-  /**
-   * Get custom theme colors
-   * Pure storage operation - no business logic
-   */
-  static async getCustomColors() {
-    try {
-      const settings = await this.getSettings();
-      return settings?.customColors || null;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Save custom theme colors
-   * Pure storage operation - no business logic
-   */
-  static async setCustomColors(
-    customColors: AppearanceSettings["customColors"],
-  ): Promise<void> {
-    const currentSettings = (await this.getSettings()) || {
-      themeMode: "dark",
-    };
-    await this.setSettings({
-      ...currentSettings,
-      customColors,
-    });
-  }
-
-  /**
-   * Clear all appearance settings
-   * Pure storage operation - no business logic
-   */
-  static async clear(): Promise<void> {
-    const result = await storageRepository.removeItem(
-      STORAGE_KEYS.APPEARANCE_SETTINGS,
-    );
-    if (!result.success) {
-      throw new Error("Failed to clear appearance settings");
-    }
-  }
-}

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,
-    });
-  },
-}));