@umituz/react-native-settings 4.23.68 → 4.23.70

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

@@ -13,130 +13,182 @@ declare const __DEV__: boolean;
 
 type LocalizationStoreType = LocalizationState & LocalizationActions & LocalizationGetters;
 
-// Mutex to prevent race condition in initialize
-let initializeInProgress = false;
-// Debounce timer for language switching
-let languageSwitchTimer: ReturnType<typeof setTimeout> | null = null;
 const LANGUAGE_SWITCH_DEBOUNCE_MS = 300;
-// Track pending promise resolvers to ensure all get resolved
-let pendingResolvers: Array<() => void> = [];
-
-export const useLocalizationStore = create<LocalizationStoreType>((set, get) => ({
-  // State
-  currentLanguage: 'en-US',
-  isRTL: false,
-  isInitialized: false,
-  supportedLanguages: languageRepository.getLanguages(),
-
-  // Actions
-  initialize: async () => {
-    const { isInitialized: alreadyInitialized } = get();
-
-    // Atomic check: both state flag AND in-progress mutex
-    if (alreadyInitialized || initializeInProgress) {
-      return;
-    }
-
-    // Set mutex immediately (synchronous)
-    initializeInProgress = true;
-
-    try {
-      const result = await LanguageInitializer.initialize();
-
-      set({
-        currentLanguage: result.languageCode,
-        isRTL: result.isRTL,
-        isInitialized: true,
-      });
-    } catch {
-      set({
-        currentLanguage: 'en-US',
-        isRTL: false,
-        isInitialized: true,
-      });
-    } finally {
-      // Reset mutex after completion (success or failure)
-      initializeInProgress = false;
-    }
-  },
-
-  setLanguage: async (languageCode: string) => {
-    // Debounce rapid language switches
-    if (languageSwitchTimer) {
-      clearTimeout(languageSwitchTimer);
-    }
-
-    return new Promise<void>((resolve) => {
-      // Add this resolver to pending list
-      pendingResolvers.push(resolve);
-
-      languageSwitchTimer = setTimeout(async () => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log('[LocalizationStore] setLanguage called:', languageCode);
-        }
 
+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 LanguageSwitcher.switchLanguage(languageCode);
+          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__) {
-            console.log('[LocalizationStore] LanguageSwitcher result:', result);
+            console.error('[LocalizationStore] Initialization failed:', error);
           }
 
           set({
-            currentLanguage: result.languageCode,
-            isRTL: result.isRTL,
+            currentLanguage: 'en-US',
+            isRTL: false,
+            isInitialized: true,
           });
 
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log('[LocalizationStore] Store updated with new language:', result.languageCode);
+          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);
           }
-        } catch (error) {
+          reject(error);
+        };
+
+        languageSwitchTimer = setTimeout(async () => {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error('[LocalizationStore] Language switch failed:', error);
+            console.log('[LocalizationStore] setLanguage called:', languageCode);
           }
-        }
 
+          try {
+            const result = await LanguageSwitcher.switchLanguage(languageCode);
+
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.log('[LocalizationStore] LanguageSwitcher result:', result);
+            }
+
+            set({
+              currentLanguage: result.languageCode,
+              isRTL: result.isRTL,
+            });
+
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.log('[LocalizationStore] Store updated with new language:', result.languageCode);
+            }
+
+            // 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__) {
+              console.error('[LocalizationStore] Language switch failed:', error);
+            }
+
+            // 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;
 
-        // Resolve ALL pending promises (not just the latest)
-        const resolvers = [...pendingResolvers];
-        pendingResolvers = [];
-        resolvers.forEach(r => r());
-      }, 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 = [];
-    resolvers.forEach(r => r());
-    // Reset mutex
-    initializeInProgress = false;
-
-    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();
-  },
-}));
+      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();
+    },
+  };
+});

package/src/domains/notifications/infrastructure/services/NotificationManager.ts

@@ -6,13 +6,11 @@
  */
 
 import * as Notifications from 'expo-notifications';
-import * as Device from 'expo-device';
-import { Platform } from 'react-native';
 import { NotificationPermissions } from './NotificationPermissions';
 import { NotificationScheduler } from './NotificationScheduler';
 import { NotificationBadgeManager } from './NotificationBadgeManager';
 import { devLog, devError } from '../utils/dev';
-import type { NotificationTrigger, ScheduleNotificationOptions, ScheduledNotification } from './types';
+import type { ScheduleNotificationOptions, ScheduledNotification } from './types';
 
 export class NotificationManager {
   private permissions: NotificationPermissions;

package/src/domains/notifications/infrastructure/services/NotificationScheduler.ts

@@ -1,5 +1,5 @@
 import * as Notifications from 'expo-notifications';
-import type { NotificationTrigger, ScheduleNotificationOptions, ScheduledNotification } from './types';
+import type { ScheduleNotificationOptions, ScheduledNotification } from './types';
 
 export class NotificationScheduler {
   async scheduleNotification(options: ScheduleNotificationOptions): Promise<string> {
@@ -69,7 +69,7 @@ export class NotificationScheduler {
       content: {
         title: notification.content.title ?? '',
         body: notification.content.body ?? '',
-        data: notification.content.data as Record<string, unknown>,
+        data: notification.content.data as Record<string, string | number | boolean | null>,
       },
       trigger: notification.trigger,
     }));

package/src/domains/notifications/quietHours/presentation/components/QuietHoursCard.tsx

@@ -8,7 +8,6 @@ import { View, TouchableOpacity, StyleSheet } from 'react-native';
 import { AtomicText, AtomicIcon, AtomicCard } from '@umituz/react-native-design-system';
 import { Switch } from 'react-native';
 import { useAppDesignTokens } from '@umituz/react-native-design-system';
-import { SettingRow } from '../../../presentation/components/SettingRow';
 import type { QuietHoursConfig, QuietHoursTranslations } from '../../../infrastructure/services/types';
 
 export interface QuietHoursCardProps {

package/src/domains/notifications/reminders/infrastructure/hooks/useReminderActions.ts

@@ -13,7 +13,7 @@ import type { Reminder, CreateReminderInput, UpdateReminderInput } from '../../.
 const scheduler = new NotificationScheduler();
 
 export const useReminderActions = () => {
-  const { addReminder, updateReminder, deleteReminder, toggleReminder } = useRemindersStore();
+  const { addReminder, updateReminder, deleteReminder, toggleReminder: _toggleReminder } = useRemindersStore();
 
   const createReminder = useCallback(async (input: CreateReminderInput): Promise<Reminder> => {
     const now = new Date().toISOString();
@@ -34,7 +34,9 @@ export const useReminderActions = () => {
         data: { reminderId: reminder.id },
       });
       reminder.notificationId = notificationId;
-    } catch {
+    } catch (error) {
+      // Log error for debugging
+      console.error('[useReminderActions] Failed to schedule notification:', error);
       reminder.enabled = false;
     }
 
@@ -44,25 +46,39 @@ export const useReminderActions = () => {
   }, [addReminder]);
 
   const editReminder = useCallback(async (id: string, input: UpdateReminderInput): Promise<void> => {
-    const { reminders } = useRemindersStore.getState();
-    const existing = reminders.find(r => r.id === id);
-    if (!existing) return;
+    // Get current state BEFORE async operations to prevent race condition
+    const existing = useRemindersStore.getState().reminders.find(r => r.id === id);
+
+    if (!existing) {
+      throw new Error(`Reminder with id ${id} not found`);
+    }
 
     if (existing.notificationId) {
-      await scheduler.cancelNotification(existing.notificationId);
+      try {
+        await scheduler.cancelNotification(existing.notificationId);
+      } catch (error) {
+        console.error('[useReminderActions] Failed to cancel notification:', error);
+        // Continue with update even if cancellation fails
+      }
     }
 
     const updated: Reminder = { ...existing, ...input, updatedAt: new Date().toISOString() };
 
     if (updated.enabled) {
-      const trigger = buildTrigger(updated);
-      const notificationId = await scheduler.scheduleNotification({
-        title: updated.title,
-        body: updated.body,
-        trigger,
-        data: { reminderId: updated.id },
-      });
-      updated.notificationId = notificationId;
+      try {
+        const trigger = buildTrigger(updated);
+        const notificationId = await scheduler.scheduleNotification({
+          title: updated.title,
+          body: updated.body,
+          trigger,
+          data: { reminderId: updated.id },
+        });
+        updated.notificationId = notificationId;
+      } catch (error) {
+        console.error('[useReminderActions] Failed to schedule notification:', error);
+        updated.enabled = false;
+        updated.notificationId = undefined;
+      }
     } else {
       updated.notificationId = undefined;
     }
@@ -71,24 +87,41 @@ export const useReminderActions = () => {
   }, [updateReminder]);
 
   const removeReminder = useCallback(async (id: string): Promise<void> => {
-    const { reminders } = useRemindersStore.getState();
-    const reminder = reminders.find(r => r.id === id);
+    // Get current state BEFORE async operations to prevent race condition
+    const reminder = useRemindersStore.getState().reminders.find(r => r.id === id);
 
-    if (reminder?.notificationId) {
-      await scheduler.cancelNotification(reminder.notificationId);
+    if (!reminder) {
+      throw new Error(`Reminder with id ${id} not found`);
+    }
+
+    if (reminder.notificationId) {
+      try {
+        await scheduler.cancelNotification(reminder.notificationId);
+      } catch (error) {
+        console.error('[useReminderActions] Failed to cancel notification:', error);
+        // Continue with deletion even if cancellation fails
+      }
     }
 
     await deleteReminder(id);
   }, [deleteReminder]);
 
   const toggleReminderEnabled = useCallback(async (id: string): Promise<void> => {
-    const { reminders } = useRemindersStore.getState();
-    const reminder = reminders.find(r => r.id === id);
-    if (!reminder) return;
+    // Get current state BEFORE async operations to prevent race condition
+    const reminder = useRemindersStore.getState().reminders.find(r => r.id === id);
+
+    if (!reminder) {
+      throw new Error(`Reminder with id ${id} not found`);
+    }
 
     if (reminder.enabled && reminder.notificationId) {
-      await scheduler.cancelNotification(reminder.notificationId);
-      await updateReminder(id, { enabled: false, notificationId: undefined });
+      try {
+        await scheduler.cancelNotification(reminder.notificationId);
+        await updateReminder(id, { enabled: false, notificationId: undefined });
+      } catch (error) {
+        console.error('[useReminderActions] Failed to disable reminder:', error);
+        throw error; // Re-throw to allow caller to handle
+      }
     } else if (!reminder.enabled) {
       try {
         const trigger = buildTrigger(reminder);
@@ -99,8 +132,10 @@ export const useReminderActions = () => {
           data: { reminderId: reminder.id },
         });
         await updateReminder(id, { enabled: true, notificationId });
-      } catch {
-        await updateReminder(id, { enabled: false });
+      } catch (error) {
+        console.error('[useReminderActions] Failed to enable reminder:', error);
+        await updateReminder(id, { enabled: false }); // Ensure disabled state
+        throw error; // Re-throw to allow caller to handle
       }
     }
   }, [updateReminder]);

package/src/domains/notifications/reminders/presentation/screens/ReminderListScreen.tsx

@@ -3,12 +3,12 @@
  * Displays list of reminders with add, edit, delete functionality
  */
 
-import React, { useEffect, useMemo, useCallback } from 'react';
+import React, { useMemo, useCallback } from 'react';
 import { View, FlatList, StyleSheet, TouchableOpacity } from 'react-native';
 import { AtomicText, AtomicIcon, AtomicSpinner } from '@umituz/react-native-design-system';
 import { useAppDesignTokens } from '@umituz/react-native-design-system';
 import { ReminderItem } from '../components/ReminderItem';
-import { useRemindersStore, useReminders, useRemindersLoading } from '../../infrastructure/storage/RemindersStore';
+import { useReminders, useRemindersLoading } from '../../infrastructure/storage/RemindersStore';
 import { useReminderActions } from '../../infrastructure/hooks/useReminderActions';
 import type { Reminder, ReminderTranslations } from '../../../infrastructure/services/types';
 

package/src/domains/rating/presentation/components/RatingPromptModal.tsx

@@ -4,7 +4,7 @@
  */
 
 import React from "react";
-import { Modal, View, StyleSheet, type StyleProp, type ViewStyle } from "react-native";
+import { Modal, View, StyleSheet } from "react-native";
 import {
   AtomicText,
   AtomicButton,

package/src/domains/rating/presentation/components/StarRating.tsx

@@ -61,7 +61,7 @@ export const StarRating: React.FC<StarRatingProps> = ({
     );
 };
 
-const getStyles = (tokens: ReturnType<typeof useAppDesignTokens>) =>
+const getStyles = (_tokens: ReturnType<typeof useAppDesignTokens>) =>
   StyleSheet.create({
     container: {
         flexDirection: "row",

package/src/presentation/components/SettingsErrorBoundary.tsx

@@ -22,33 +22,29 @@ interface State {
 }
 
 export class SettingsErrorBoundary extends Component<Props, State> {
-  constructor(props: Props) {
-    super(props);
-    // Initialize state using unknown to avoid type assertion issues
-    (this as unknown as { state: State }).state = { hasError: false };
-  }
+  override state: State = {
+    hasError: false,
+    error: undefined,
+  };
 
   static getDerivedStateFromError(error: Error): State {
     return { hasError: true, error };
   }
 
-  componentDidCatch(_error: Error, _errorInfo: React.ErrorInfo): void {
+  override componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {
     // Log error to console in development
     if (__DEV__) {
-      console.error('Settings Error Boundary caught an error:', _error);
-      console.error('Error Info:', _errorInfo);
+      console.error('Settings Error Boundary caught an error:', error);
+      console.error('Error Info:', errorInfo);
     }
+
+    // TODO: Send to error tracking service in production
+    // Example: Sentry.captureException(error, { contexts: { react: { errorInfo } } });
   }
 
-  render(): ReactNode {
-    // Safe access through unknown to avoid type assertion issues
-    const self = this as unknown as { state: State; props: Props };
-    const hasError = self.state.hasError;
-    const error = self.state.error;
-    const fallback = self.props.fallback;
-    const fallbackTitle = self.props.fallbackTitle;
-    const fallbackMessage = self.props.fallbackMessage;
-    const children = self.props.children;
+  override render(): ReactNode {
+    const { hasError, error } = this.state;
+    const { children, fallback, fallbackTitle, fallbackMessage } = this.props;
 
     if (hasError) {
       if (fallback) {
@@ -140,4 +136,4 @@ const styles = StyleSheet.create({
     textAlign: 'center',
     lineHeight: 20,
   },
-});
+});

package/src/presentation/components/SettingsFooter.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 import { View, StyleSheet } from "react-native";
-import { useAppDesignTokens, AtomicText } from "@umituz/react-native-design-system";
+import { AtomicText } from "@umituz/react-native-design-system";
 
 export interface SettingsFooterProps {
   versionText?: string;
@@ -13,8 +13,6 @@ export const SettingsFooter: React.FC<SettingsFooterProps> = ({
   appVersion,
   versionLabel,
 }) => {
-  const tokens = useAppDesignTokens();
-
   const displayText = versionText || (appVersion && versionLabel
     ? `${versionLabel} ${appVersion}`
     : appVersion);

package/src/presentation/components/SettingsItemCard.tsx

@@ -51,6 +51,23 @@ export const SettingsItemCard: React.FC<SettingsItemCardProps> = ({
     const tokens = useAppDesignTokens();
     const colors = tokens.colors;
 
+    // Validate props in development
+    if (__DEV__) {
+        if (!title || typeof title !== 'string') {
+            console.warn('[SettingsItemCard] Invalid title prop:', title);
+        }
+        if (description && typeof description !== 'string') {
+            console.warn('[SettingsItemCard] Invalid description prop:', description);
+        }
+        if (showSwitch && !onSwitchChange) {
+            console.warn('[SettingsItemCard] Switch shown but no onSwitchChange provided. Switch changes will be ignored.');
+        }
+    }
+
+    // Sanitize string props (trim and limit length)
+    const sanitizedTitle = title?.trim().slice(0, 200) || '';
+    const sanitizedDescription = description?.trim().slice(0, 500);
+
     const defaultIconBg = iconBgColor || withAlpha(colors.primary, 0.15);
     const defaultIconColor = iconColor || colors.primary;
     const isClickable = !!onPress && !showSwitch;
@@ -61,7 +78,11 @@ export const SettingsItemCard: React.FC<SettingsItemCardProps> = ({
             return (
                 <AtomicSwitch
                     value={!!switchValue}
-                    onValueChange={onSwitchChange || (() => {})}
+                    onValueChange={onSwitchChange || (() => {
+                        if (__DEV__) {
+                            console.warn('[SettingsItemCard] Switch toggled but no onSwitchChange handler provided');
+                        }
+                    })}
                     disabled={disabled}
                 />
             );
@@ -82,13 +103,13 @@ export const SettingsItemCard: React.FC<SettingsItemCardProps> = ({
                     type="bodyLarge"
                     color={disabled ? "onSurfaceVariant" : "onSurface"}
                     numberOfLines={1}
-                    style={{ marginBottom: description ? tokens.spacing.xs : 0, opacity: disabled ? 0.6 : 1 }}
+                    style={{ marginBottom: sanitizedDescription ? tokens.spacing.xs : 0, opacity: disabled ? 0.6 : 1 }}
                 >
-                    {title}
+                    {sanitizedTitle}
                 </AtomicText>
-                {!!description && (
+                {!!sanitizedDescription && (
                     <AtomicText type="bodyMedium" color="textSecondary" numberOfLines={2}>
-                        {description}
+                        {sanitizedDescription}
                     </AtomicText>
                 )}
             </View>
@@ -113,7 +134,7 @@ export const SettingsItemCard: React.FC<SettingsItemCardProps> = ({
             {!!sectionTitle && (
                 <View style={styles.headerContainer}>
                     <AtomicText type="labelMedium" color="textSecondary" style={{ textTransform: 'uppercase' }}>
-                        {sectionTitle}
+                        {sectionTitle.trim().slice(0, 100)}
                     </AtomicText>
                 </View>
             )}

package/src/presentation/hooks/queries/useSettingsQuery.ts

@@ -6,7 +6,6 @@
 
 import { useQuery } from '@umituz/react-native-design-system';
 import { getSettingsService } from '../../../infrastructure/services/SettingsService';
-import type { UserSettings } from '../../../application/ports/ISettingsRepository';
 
 export const SETTINGS_QUERY_KEY = ['settings'];
 

package/src/presentation/hooks/useSettings.ts

@@ -10,6 +10,14 @@ import { useUpdateSettingsMutation, useResetSettingsMutation } from './mutations
 import type { UserSettings } from '../../application/ports/ISettingsRepository';
 
 export const useSettings = (userId: string) => {
+    // Validate userId
+    if (!userId || typeof userId !== 'string' || userId.trim() === '') {
+        throw new Error(
+            'Invalid userId: must be a non-empty string. ' +
+            'Received: ' + (userId === null ? 'null' : typeof userId)
+        );
+    }
+
     const {
         data: settings,
         isLoading: loading,