@umituz/react-native-settings 4.23.86 → 4.23.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-settings",
-  "version": "4.23.86",
+  "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",

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

@@ -7,6 +7,7 @@ import React, { useState } from "react";
 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/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/reminders/presentation/components/ReminderForm.tsx

@@ -11,15 +11,13 @@ import { TimePresetSelector } from './TimePresetSelector';
 import { FrequencySelector } from './FrequencySelector';
 import { WeekdaySelector } from './WeekdaySelector';
 import { FormButton } from './FormButton';
-import { 
-  DEFAULT_HOUR, 
-  DEFAULT_MINUTE, 
-  DEFAULT_WEEKDAY, 
-  MAX_TITLE_LENGTH, 
-  MAX_BODY_LENGTH, 
-  VALID_HOUR_RANGE, 
-  VALID_MINUTE_RANGE, 
-  VALID_WEEKDAY_RANGE,
+import { validateReminderForm } from '../../../../../infrastructure/utils/validation';
+import {
+  DEFAULT_HOUR,
+  DEFAULT_MINUTE,
+  DEFAULT_WEEKDAY,
+  MAX_TITLE_LENGTH,
+  MAX_BODY_LENGTH,
   type ReminderFormProps,
 } from './ReminderForm.constants';
 import { createReminderFormStyles as createStyles } from './ReminderForm.styles';
@@ -44,25 +42,16 @@ export const ReminderForm: React.FC<ReminderFormProps> = ({
   const [minute, setMinute] = useState(initialData?.minute ?? DEFAULT_MINUTE);
   const [weekday, setWeekday] = useState(initialData?.weekday ?? DEFAULT_WEEKDAY);
   const [isCustomTime, setIsCustomTime] = useState(!initialData?.timePresetId);
-
-  // Validation helper functions
-  const isValidHour = useCallback((h: number): boolean => {
-    return h >= VALID_HOUR_RANGE.min && h <= VALID_HOUR_RANGE.max;
-  }, []);
-
-  const isValidMinute = useCallback((m: number): boolean => {
-    return m >= VALID_MINUTE_RANGE.min && m <= VALID_MINUTE_RANGE.max;
-  }, []);
-
-  const isValidWeekday = useCallback((w: number): boolean => {
-    return w >= VALID_WEEKDAY_RANGE.min && w <= VALID_WEEKDAY_RANGE.max;
-  }, []);
+  // FIXED: Add error state for user feedback
+  const [error, setError] = useState<string | null>(null);
 
   const handlePresetSelect = useCallback((preset: TimePreset) => {
     setSelectedPresetId(preset.id);
     setHour(preset.hour);
     setMinute(preset.minute);
     setIsCustomTime(false);
+    // Clear error when user changes something
+    setError(null);
   }, []);
 
   const handleCustomSelect = useCallback(() => {
@@ -74,29 +63,26 @@ export const ReminderForm: React.FC<ReminderFormProps> = ({
     const trimmedTitle = title.trim();
     const trimmedBody = body.trim();
 
-    // Validate title
-    if (!trimmedTitle) {
-      return;
-    }
-
-    if (trimmedTitle.length > MAX_TITLE_LENGTH) {
-      return;
-    }
-
-    // Validate body length
-    if (trimmedBody.length > MAX_BODY_LENGTH) {
-      return;
-    }
+    // Validate using centralized validation
+    const validationResult = validateReminderForm({
+      title: trimmedTitle,
+      body: trimmedBody,
+      frequency,
+      hour,
+      minute,
+      weekday,
+      maxTitleLength: MAX_TITLE_LENGTH,
+      maxBodyLength: MAX_BODY_LENGTH,
+    });
 
-    // Validate time values
-    if (!isValidHour(hour) || !isValidMinute(minute)) {
+    if (!validationResult.isValid) {
+      // FIXED: Show error to user
+      setError(validationResult.error || "Validation failed");
       return;
     }
 
-    // Validate weekday if frequency is weekly
-    if (frequency === 'weekly' && !isValidWeekday(weekday)) {
-      return;
-    }
+    // Clear error and proceed
+    setError(null);
 
     // Sanitize input (React Native handles XSS, but we trim extra whitespace)
     const sanitizedTitle = trimmedTitle.replace(/\s+/g, ' ').trim();
@@ -112,7 +98,7 @@ export const ReminderForm: React.FC<ReminderFormProps> = ({
       weekday: frequency === 'weekly' ? weekday : undefined,
       dayOfMonth: frequency === 'monthly' ? 1 : undefined,
     });
-  }, [title, body, frequency, selectedPresetId, hour, minute, weekday, isCustomTime, onSave, isValidHour, isValidMinute, isValidWeekday]);
+  }, [title, body, frequency, selectedPresetId, hour, minute, weekday, isCustomTime, onSave]);
 
   return (
     <ScrollView style={styles.container} showsVerticalScrollIndicator={false}>
@@ -121,7 +107,10 @@ export const ReminderForm: React.FC<ReminderFormProps> = ({
         <TextInput
           style={styles.input}
           value={title}
-          onChangeText={setTitle}
+          onChangeText={(text) => {
+            setTitle(text);
+            setError(null); // Clear error on input
+          }}
           placeholder={translations.titlePlaceholder}
           placeholderTextColor={tokens.colors.textSecondary}
         />
@@ -132,7 +121,10 @@ export const ReminderForm: React.FC<ReminderFormProps> = ({
         <TextInput
           style={[styles.input, styles.multilineInput]}
           value={body}
-          onChangeText={setBody}
+          onChangeText={(text) => {
+            setBody(text);
+            setError(null); // Clear error on input
+          }}
           placeholder={translations.bodyPlaceholder}
           placeholderTextColor={tokens.colors.textSecondary}
           multiline
@@ -171,9 +163,23 @@ export const ReminderForm: React.FC<ReminderFormProps> = ({
         </View>
       )}
 
+      {/* FIXED: Show error message to user */}
+      {error && (
+        <View style={styles.section}>
+          <AtomicText type="bodySmall" color="error">
+            {error}
+          </AtomicText>
+        </View>
+      )}
+
       <View style={styles.buttonRow}>
         <FormButton label={translations.cancelButton} onPress={onCancel} variant="secondary" />
-        <FormButton label={translations.saveButton} onPress={handleSave} disabled={!title.trim()} />
+        {/* FIXED: Disable button when form is invalid */}
+        <FormButton
+          label={translations.saveButton}
+          onPress={handleSave}
+          disabled={!title.trim() || !frequency}
+        />
       </View>
     </ScrollView>
   );