@umituz/react-native-settings 4.23.85 → 4.23.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-settings",
-  "version": "4.23.85",
+  "version": "4.23.87",
   "description": "Complete settings hub for React Native apps - consolidated package with settings, localization, about, legal, appearance, feedback, FAQs, rating, and gamification",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -74,8 +74,8 @@
     "@types/react": "~19.1.10",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
-    "@umituz/react-native-auth": "^3.6.49",
-    "@umituz/react-native-design-system": "*",
+    "@umituz/react-native-auth": "^3.6.76",
+    "@umituz/react-native-design-system": "latest",
     "@umituz/react-native-firebase": "^1.13.102",
     "@umituz/react-native-sentry": "*",
     "eslint": "^8.57.0",

package/src/domains/about/presentation/hooks/useAboutInfo.ts

@@ -122,7 +122,7 @@ export const useAboutInfo = (
           setAppInfo(defaultAppInfo);
           isInitializedRef.current = true;
         }
-      }).catch((error) => {
+      }).catch((_error) => {
       });
     }
   }, [initialConfig, autoInit]);

package/src/domains/faqs/presentation/screens/FAQScreen.tsx

@@ -6,7 +6,7 @@
 
 import React, { useMemo } from 'react';
 import { View, ScrollView, StyleSheet, ViewStyle, TextStyle, useWindowDimensions } from 'react-native';
-import { useAppDesignTokens, AtomicText, ScreenLayout, getContentMaxWidth, NavigationHeader, useAppNavigation } from '@umituz/react-native-design-system';
+import { useAppDesignTokens, ScreenLayout, getContentMaxWidth, NavigationHeader, useAppNavigation } from '@umituz/react-native-design-system';
 import { FAQCategory } from '../../domain/entities/FAQEntity';
 import { useFAQSearch } from '../hooks/useFAQSearch';
 import { useFAQExpansion } from '../hooks/useFAQExpansion';

package/src/domains/feedback/presentation/components/FeedbackForm.styles.ts

@@ -1,7 +1,7 @@
 import { StyleSheet } from "react-native";
 import type { useAppDesignTokens } from "@umituz/react-native-design-system";
 
-export const getFeedbackFormStyles = (tokens: ReturnType<typeof useAppDesignTokens>) =>
+export const getFeedbackFormStyles = (_tokens: ReturnType<typeof useAppDesignTokens>) =>
   StyleSheet.create({
     container: {
         width: "100%",

package/src/domains/feedback/presentation/components/FeedbackForm.tsx

@@ -4,9 +4,10 @@
  */
 
 import React, { useState } from "react";
-import { View, StyleSheet, TouchableOpacity, ScrollView, TextInput } from "react-native";
+import { View, TouchableOpacity, ScrollView, TextInput } from "react-native";
 import { useAppDesignTokens, AtomicText, AtomicButton, AtomicIcon } from "@umituz/react-native-design-system";
 import type { FeedbackType, FeedbackRating } from "../../domain/entities/FeedbackEntity";
+import { validateFeedbackForm } from "../../../../infrastructure/utils/validation";
 
 import { getFeedbackFormStyles as getStyles } from "./FeedbackForm.styles";
 
@@ -40,9 +41,15 @@ export const FeedbackForm: React.FC<FeedbackFormProps> = ({
     const [isSubmittingLocal, setIsSubmittingLocal] = useState(false);
 
     const handleSubmit = async () => {
-        // Validate input
-        if (!description.trim()) {
-            setError("Please provide a description");
+        // Validate using centralized validation
+        const validationResult = validateFeedbackForm({
+            type: selectedType,
+            rating,
+            description,
+        });
+
+        if (!validationResult.isValid) {
+            setError(validationResult.error || "Validation failed");
             return;
         }
 

package/src/domains/gamification/components/GamificationScreen/GamificationScreen.tsx

@@ -5,7 +5,7 @@
  */
 
 import React from "react";
-import { View, ScrollView } from "react-native";
+import { View } from "react-native";
 import { useAppDesignTokens, AtomicText, ScreenLayout, NavigationHeader, useAppNavigation } from "@umituz/react-native-design-system";
 import { LevelProgress } from "../LevelProgress";
 import { StreakDisplay } from "../StreakDisplay";
@@ -27,12 +27,8 @@ export const GamificationScreenInner: React.FC<GamificationScreenProps> = ({
   achievements,
   streakProps,
   emptyAchievementsText,
-  containerStyle,
-  headerStyle,
-  titleStyle,
   sectionTitleStyle,
   accentColor,
-  backgroundColor,
   cardBackgroundColor,
   textColor,
   subtextColor,
@@ -43,7 +39,6 @@ export const GamificationScreenInner: React.FC<GamificationScreenProps> = ({
 
   // Use tokens for fallbacks
   const finalAccentColor = accentColor || tokens.colors.primary;
-  const finalBackgroundColor = backgroundColor || tokens.colors.backgroundPrimary;
   const finalCardBackgroundColor = cardBackgroundColor || tokens.colors.surface;
   const finalTextColor = textColor || tokens.colors.textPrimary;
   const finalSubtextColor = subtextColor || tokens.colors.textSecondary;

package/src/domains/gamification/store/gamificationStore.ts

@@ -78,16 +78,16 @@ export const useGamificationStore = createStore<GamificationState, GamificationA
       const state = get();
       const pointsToAdd = currentConfig?.pointsPerAction ?? 15;
 
+      const newTotalTasks = state.totalTasksCompleted + 1;
+
       set({
-        totalTasksCompleted: state.totalTasksCompleted + 1,
+        totalTasksCompleted: newTotalTasks,
         points: state.points + pointsToAdd,
       });
 
-      // Update streak
-      get().updateStreak();
-
-      // Check achievements
-      get().checkAchievements();
+      const actions = get() as GamificationActions;
+      actions.updateStreak();
+      actions.checkAchievements();
     },
 
     updateStreak: () => {
@@ -121,7 +121,6 @@ export const useGamificationStore = createStore<GamificationState, GamificationA
 
       const state = get();
 
-      // Safety check for achievements array
       if (!state.achievements || state.achievements.length === 0) {
         return [];
       }

package/src/domains/localization/infrastructure/storage/LocalizationStore.ts

@@ -3,187 +3,56 @@
  * Creates and manages localization state with proper separation of concerns
  */
 
-import { create } from 'zustand';
-import type { LocalizationState, LocalizationActions, LocalizationGetters } from './types/LocalizationState';
-import { LanguageInitializer } from './LanguageInitializer';
-import { LanguageSwitcher } from './LanguageSwitcher';
-import { languageRepository } from '../repository/LanguageRepository';
-
-declare const __DEV__: boolean;
+import { create } from "zustand";
+import type { LocalizationState, LocalizationActions, LocalizationGetters } from "./types/LocalizationState";
+import { languageRepository } from "../repository/LanguageRepository";
+import { InitializationManager, LanguageSwitchManager, localizationGetters } from "./localizationStoreUtils";
 
 type LocalizationStoreType = LocalizationState & LocalizationActions & LocalizationGetters;
 
-const LANGUAGE_SWITCH_DEBOUNCE_MS = 300;
-
-export const useLocalizationStore = create<LocalizationStoreType>((set, get) => {
-  // Instance-level state to prevent memory leaks
-  let initializeInProgress = false;
-  let initializePromise: Promise<void> | null = null;
-  let languageSwitchTimer: ReturnType<typeof setTimeout> | null = null;
-  const pendingResolvers: Array<() => void> = [];
-
-  return {
-    // State
-    currentLanguage: 'en-US',
-    isRTL: false,
-    isInitialized: false,
-    supportedLanguages: languageRepository.getLanguages(),
-
-    // Actions
-    initialize: async () => {
-      const { isInitialized: alreadyInitialized } = get();
-
-      // Return existing promise if initialization is in progress
-      if (initializeInProgress && initializePromise) {
-        return initializePromise;
-      }
-
-      // Return if already initialized
-      if (alreadyInitialized) {
-        return;
-      }
-
-      // Set mutex and create promise
-      initializeInProgress = true;
-      initializePromise = (async () => {
-        try {
-          const result = await LanguageInitializer.initialize();
-
-          set({
-            currentLanguage: result.languageCode,
-            isRTL: result.isRTL,
-            isInitialized: true,
-          });
-        } catch (error) {
-          // Log and set fallback state
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-          }
-
-          set({
-            currentLanguage: 'en-US',
-            isRTL: false,
-            isInitialized: true,
-          });
-
-          throw error; // Re-throw to allow error handling
-        } finally {
-          initializeInProgress = false;
-          initializePromise = null;
-        }
-      })();
-
-      return initializePromise;
-    },
-
-    setLanguage: async (languageCode: string) => {
-      // Validate input
-      if (!languageCode || typeof languageCode !== 'string') {
-        throw new Error('Invalid language code provided');
-      }
-
-      // Clear existing timer
-      if (languageSwitchTimer) {
-        clearTimeout(languageSwitchTimer);
-        languageSwitchTimer = null;
-      }
-
-      return new Promise<void>((resolve, reject) => {
-        // Add resolver to pending list
-        pendingResolvers.push(() => {
-          // Resolve successfully
-          resolve();
-        });
-
-        // Create rejection handler
-        const rejectAndCleanup = (error: Error) => {
-          // Remove this resolver
-          const index = pendingResolvers.findIndex(r => r === resolve);
-          if (index > -1) {
-            pendingResolvers.splice(index, 1);
-          }
-          reject(error);
-        };
-
-        languageSwitchTimer = setTimeout(async () => {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-          }
-
-          try {
-            const result = await LanguageSwitcher.switchLanguage(languageCode);
-
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-            }
-
-            set({
-              currentLanguage: result.languageCode,
-              isRTL: result.isRTL,
-            });
-
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-            }
-
-            // Resolve ALL pending promises
-            const resolvers = [...pendingResolvers];
-            pendingResolvers.length = 0; // Clear array
-            resolvers.forEach(r => r());
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error : new Error(String(error));
-
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-            }
-
-            // Reject all pending promises
-            const resolvers = [...pendingResolvers];
-            pendingResolvers.length = 0; // Clear array
-            resolvers.forEach(() => {
-              // Each resolver is wrapped to handle rejection
-              // Note: We can't reject promises already created, so we just clear them
-            });
-
-            // Reject this specific promise
-            rejectAndCleanup(errorMessage);
-          } finally {
-            languageSwitchTimer = null;
-          }
-        }, LANGUAGE_SWITCH_DEBOUNCE_MS);
-      });
-    },
-
-    reset: () => {
-      // Clear any pending language switch
-      if (languageSwitchTimer) {
-        clearTimeout(languageSwitchTimer);
-        languageSwitchTimer = null;
-      }
-
-      // Resolve any pending promises to prevent hanging
-      const resolvers = [...pendingResolvers];
-      pendingResolvers.length = 0; // Clear array
-      resolvers.forEach(r => r());
-
-      // Reset mutex
-      initializeInProgress = false;
-      initializePromise = null;
-
-      set({
-        currentLanguage: 'en-US',
-        isRTL: false,
-        isInitialized: false,
-      });
-    },
-
-    // Getters
-    getCurrentLanguage: () => {
-      const { currentLanguage } = get();
-      return languageRepository.getLanguageByCode(currentLanguage);
-    },
-
-    isLanguageSupported: (code: string) => {
-      return languageRepository.isLanguageSupported(code);
-    },
-
-    getSupportedLanguages: () => {
-      return languageRepository.getLanguages();
-    },
-  };
-});
+// Instance-level managers
+const initManager = new InitializationManager();
+const switchManager = new LanguageSwitchManager();
+
+export const useLocalizationStore = create<LocalizationStoreType>((set, get) => ({
+  // State
+  currentLanguage: "en-US",
+  isRTL: false,
+  isInitialized: false,
+  supportedLanguages: languageRepository.getLanguages(),
+
+  // Actions
+  initialize: async () => {
+    const { isInitialized } = get();
+    await initManager.initialize(isInitialized, set);
+  },
+
+  setLanguage: async (languageCode: string) => {
+    await switchManager.setLanguage(languageCode, set);
+  },
+
+  reset: () => {
+    initManager.reset();
+    switchManager.reset();
+
+    set({
+      currentLanguage: "en-US",
+      isRTL: false,
+      isInitialized: false,
+    });
+  },
+
+  // Getters
+  getCurrentLanguage: () => {
+    const { currentLanguage } = get();
+    return localizationGetters.getCurrentLanguage(currentLanguage);
+  },
+
+  isLanguageSupported: (code: string) => {
+    return localizationGetters.isLanguageSupported(code);
+  },
+
+  getSupportedLanguages: () => {
+    return localizationGetters.getSupportedLanguages();
+  },
+}));

package/src/domains/localization/infrastructure/storage/localizationStoreUtils.ts

@@ -0,0 +1,182 @@
+/**
+ * Localization Store Utilities
+ * Extracted business logic for localization store
+ */
+
+import { LanguageInitializer } from "./LanguageInitializer";
+import { LanguageSwitcher } from "./LanguageSwitcher";
+import { languageRepository } from "../repository/LanguageRepository";
+
+declare const __DEV__: boolean;
+
+export const LANGUAGE_SWITCH_DEBOUNCE_MS = 300;
+
+/**
+ * Manages localization initialization state
+ */
+export class InitializationManager {
+  private inProgress = false;
+  private promise: Promise<void> | null = null;
+
+  async initialize(
+    isAlreadyInitialized: boolean,
+    setState: (state: Partial<{ currentLanguage: string; isRTL: boolean; isInitialized: boolean }>) => void
+  ): Promise<void> {
+    // Return existing promise if initialization is in progress
+    if (this.inProgress && this.promise) {
+      return this.promise;
+    }
+
+    // Return if already initialized
+    if (isAlreadyInitialized) {
+      return;
+    }
+
+    // Set mutex and create promise
+    this.inProgress = true;
+    this.promise = (async () => {
+      try {
+        const result = await LanguageInitializer.initialize();
+
+        setState({
+          currentLanguage: result.languageCode,
+          isRTL: result.isRTL,
+          isInitialized: true,
+        });
+      } catch (error) {
+        // Log and set fallback state
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("Localization initialization failed:", error);
+        }
+
+        setState({
+          currentLanguage: "en-US",
+          isRTL: false,
+          isInitialized: true,
+        });
+
+        throw error; // Re-throw to allow error handling
+      } finally {
+        this.inProgress = false;
+        this.promise = null;
+      }
+    })();
+
+    return this.promise;
+  }
+
+  reset(): void {
+    this.inProgress = false;
+    this.promise = null;
+  }
+}
+
+/**
+ * Manages debounced language switching with pending promise handling
+ * FIXED: Properly rejects pending promises on error
+ */
+export class LanguageSwitchManager {
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private pendingResolvers: Array<{ resolve: () => void; reject: (error: Error) => void }> = [];
+
+  /**
+   * Sets language with debounce and promise handling
+   */
+  setLanguage(
+    languageCode: string,
+    setState: (state: Partial<{ currentLanguage: string; isRTL: boolean }>) => void
+  ): Promise<void> {
+    // Validate input
+    if (!languageCode || typeof languageCode !== "string") {
+      return Promise.reject(new Error("Invalid language code provided"));
+    }
+
+    // Clear existing timer
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      // Add resolver and rejector to pending list
+      const pendingItem = { resolve, reject };
+      this.pendingResolvers.push(pendingItem);
+
+      this.timer = setTimeout(async () => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Localization] Switching language to:", languageCode);
+        }
+
+        try {
+          const result = await LanguageSwitcher.switchLanguage(languageCode);
+
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Localization] Language switched successfully");
+          }
+
+          const stateUpdate = {
+            currentLanguage: result.languageCode,
+            isRTL: result.isRTL,
+          };
+
+          setState(stateUpdate);
+
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Localization] State updated:", stateUpdate);
+          }
+
+          // Resolve ALL pending promises
+          const resolvers = [...this.pendingResolvers];
+          this.pendingResolvers = [];
+          resolvers.forEach((r) => r.resolve());
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error : new Error(String(error));
+
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[Localization] Language switch failed:", errorMessage);
+          }
+
+          // Reject ALL pending promises - FIXED: Actually rejects them now
+          const resolvers = [...this.pendingResolvers];
+          this.pendingResolvers = [];
+          resolvers.forEach((r) => r.reject(errorMessage));
+        } finally {
+          this.timer = null;
+        }
+      }, LANGUAGE_SWITCH_DEBOUNCE_MS);
+    });
+  }
+
+  /**
+   * Clears any pending language switch and resolves all promises
+   */
+  reset(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+
+    // Resolve any pending promises to prevent hanging
+    const resolvers = [...this.pendingResolvers];
+    this.pendingResolvers = [];
+    resolvers.forEach((r) => r.resolve());
+  }
+}
+
+/**
+ * Localization getters
+ */
+export const localizationGetters = {
+  getCurrentLanguage: (currentLanguage: string) => {
+    return languageRepository.getLanguageByCode(currentLanguage);
+  },
+
+  isLanguageSupported: (code: string) => {
+    return languageRepository.isLanguageSupported(code);
+  },
+
+  getSupportedLanguages: () => {
+    return languageRepository.getLanguages();
+  },
+};

package/src/domains/notifications/infrastructure/utils/dev.ts

@@ -6,17 +6,17 @@ export const isDev = () => {
   }
 };
 
-export const devLog = (message: string, ...args: unknown[]) => {
+export const devLog = (_message: string, ..._args: unknown[]) => {
   if (isDev()) {
   }
 };
 
-export const devError = (message: string, ...args: unknown[]) => {
+export const devError = (_message: string, ..._args: unknown[]) => {
   if (isDev()) {
   }
 };
 
-export const devWarn = (message: string, ...args: unknown[]) => {
+export const devWarn = (_message: string, ..._args: unknown[]) => {
   if (isDev()) {
   }
 };

package/src/domains/notifications/reminders/presentation/components/ReminderForm.constants.ts

@@ -1,4 +1,4 @@
-import type { Reminder, ReminderFrequency, CreateReminderInput, TimePreset } from '../../../infrastructure/services/types';
+import type { Reminder, CreateReminderInput, TimePreset } from '../../../infrastructure/services/types';
 
 export const DEFAULT_HOUR = 9;
 export const DEFAULT_MINUTE = 0;