@umituz/react-native-settings 4.23.84 → 4.23.86

package/src/domains/rating/infrastructure/storage/RatingStorage.ts

@@ -24,10 +24,7 @@ export async function getEventCount(eventType: string): Promise<number> {
     const result = await storageRepository.getString(KEYS.eventCount(eventType), "0");
     const count = parseInt(unwrap(result, "0"), 10);
     return Number.isNaN(count) ? 0 : count;
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[RatingStorage] Error getting event count:", error);
-    }
+  } catch {
     return 0;
   }
 }
@@ -38,10 +35,8 @@ export async function getEventCount(eventType: string): Promise<number> {
 export async function setEventCount(eventType: string, count: number): Promise<void> {
   try {
     await storageRepository.setString(KEYS.eventCount(eventType), count.toString());
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[RatingStorage] Error setting event count:", error);
-    }
+  } catch {
+    // Silent error handling
   }
 }
 
@@ -61,10 +56,7 @@ export async function getLastPromptDate(eventType: string): Promise<string | nul
     const result = await storageRepository.getString(KEYS.lastPrompt(eventType), "");
     const date = unwrap(result, "");
     return date || null;
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[RatingStorage] Error getting last prompt date:", error);
-    }
+  } catch {
     return null;
   }
 }
@@ -75,10 +67,8 @@ export async function getLastPromptDate(eventType: string): Promise<string | nul
 export async function setLastPromptDate(eventType: string, date: string): Promise<void> {
   try {
     await storageRepository.setString(KEYS.lastPrompt(eventType), date);
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[RatingStorage] Error setting last prompt date:", error);
-    }
+  } catch {
+    // Silent error handling
   }
 }
 
@@ -89,10 +79,7 @@ export async function getHasRated(): Promise<boolean> {
   try {
     const result = await storageRepository.getString(KEYS.hasRated, "false");
     return unwrap(result, "false") === "true";
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[RatingStorage] Error getting hasRated:", error);
-    }
+  } catch {
     return false;
   }
 }
@@ -103,10 +90,8 @@ export async function getHasRated(): Promise<boolean> {
 export async function setHasRated(value: boolean): Promise<void> {
   try {
     await storageRepository.setString(KEYS.hasRated, value.toString());
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[RatingStorage] Error setting hasRated:", error);
-    }
+  } catch {
+    // Silent error handling
   }
 }
 
@@ -117,10 +102,7 @@ export async function getDismissed(): Promise<boolean> {
   try {
     const result = await storageRepository.getString(KEYS.dismissed, "false");
     return unwrap(result, "false") === "true";
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[RatingStorage] Error getting dismissed:", error);
-    }
+  } catch {
     return false;
   }
 }
@@ -131,10 +113,8 @@ export async function getDismissed(): Promise<boolean> {
 export async function setDismissed(value: boolean): Promise<void> {
   try {
     await storageRepository.setString(KEYS.dismissed, value.toString());
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[RatingStorage] Error setting dismissed:", error);
-    }
+  } catch {
+    // Silent error handling
   }
 }
 
@@ -174,9 +154,7 @@ export async function reset(eventType?: string): Promise<void> {
         ratingKeys.map((key) => storageRepository.removeItem(key))
       );
     }
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[RatingStorage] Error resetting data:", error);
-    }
+  } catch {
+    // Silent error handling
   }
 }

package/src/domains/rating/presentation/hooks/useAppRating.tsx

@@ -73,7 +73,6 @@ export function useAppRating(config: RatingConfig): UseAppRatingResult {
       }
     } catch (error) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[useAppRating] Error requesting review:", error);
       }
     }
 

package/src/infrastructure/utils/dateUtils.ts

@@ -0,0 +1,61 @@
+/**
+ * Date Utilities
+ *
+ * Helper functions for date manipulation and calculations.
+ */
+
+/**
+ * Calculate days between two dates
+ * @param dateString ISO date string
+ * @param now Current date (defaults to new Date())
+ * @returns Number of days between dates
+ */
+export function daysBetween(dateString: string, now: Date = new Date()): number {
+  const date = new Date(dateString);
+  const diffMs = now.getTime() - date.getTime();
+  return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+}
+
+/**
+ * Format date to ISO string
+ * @param date Date to format
+ * @returns ISO date string
+ */
+export function toISOString(date: Date = new Date()): string {
+  return date.toISOString();
+}
+
+/**
+ * Check if a date is within the last N days
+ * @param dateString ISO date string to check
+ * @param days Number of days to check within
+ * @returns true if date is within the last N days
+ */
+export function isWithinLastDays(dateString: string, days: number): boolean {
+  const daysDiff = daysBetween(dateString);
+  return daysDiff >= 0 && daysDiff <= days;
+}
+
+/**
+ * Check if a date has passed (is older than N days ago)
+ * @param dateString ISO date string to check
+ * @param days Number of days threshold
+ * @returns true if date is older than N days
+ */
+export function isOlderThanDays(dateString: string, days: number): boolean {
+  const daysDiff = daysBetween(dateString);
+  return daysDiff > days;
+}
+
+/**
+ * Add days to a date
+ * @param dateString ISO date string
+ * @param days Number of days to add
+ * @returns New date with days added
+ */
+export function addDays(dateString: string, days: number): Date {
+  const date = new Date(dateString);
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}

package/src/infrastructure/utils/memoComparisonUtils.ts

@@ -0,0 +1,66 @@
+/**
+ * Memo Comparison Utilities
+ *
+ * Provides reusable comparison functions for React.memo to reduce code duplication.
+ * These functions follow best practices for shallow comparison in React components.
+ */
+
+/**
+ * Standard comparison for components with config and translation props
+ * @param prevProps Previous props
+ * @param nextProps Next props
+ * @returns true if props are equal (should not re-render)
+ */
+export function compareConfigAndTranslate(
+  prevProps: Record<string, unknown>,
+  nextProps: Record<string, unknown>
+): boolean {
+  return (
+    prevProps.config === nextProps.config &&
+    prevProps.t === nextProps.t
+  );
+}
+
+/**
+ * Standard comparison for components with normalized config and features
+ * @param prevProps Previous props
+ * @param nextProps Next props
+ * @returns true if props are equal (should not re-render)
+ */
+export function compareConfigAndFeatures(
+  prevProps: Record<string, unknown>,
+  nextProps: Record<string, unknown>
+): boolean {
+  return (
+    prevProps.normalizedConfig === nextProps.normalizedConfig &&
+    prevProps.features === nextProps.features
+  );
+}
+
+/**
+ * Standard comparison for components with single prop
+ * @param propKey Property key to compare
+ * @returns Comparison function
+ */
+export function createSinglePropComparator<K extends string>(
+  propKey: K
+): (prevProps: Record<string, unknown>, nextProps: Record<string, unknown>) => boolean {
+  return (prevProps, nextProps) => prevProps[propKey] === nextProps[propKey];
+}
+
+/**
+ * Standard comparison for components with gamification config
+ * @param prevProps Previous props
+ * @param nextProps Next props
+ * @returns true if props are equal (should not re-render)
+ */
+export function compareGamificationProps(
+  prevProps: Record<string, unknown>,
+  nextProps: Record<string, unknown>
+): boolean {
+  return (
+    prevProps.config === nextProps.config &&
+    prevProps.gamificationConfig === nextProps.gamificationConfig &&
+    prevProps.t === nextProps.t
+  );
+}

package/src/infrastructure/utils/sanitizers.ts

@@ -0,0 +1,49 @@
+/**
+ * Sanitization Utilities
+ *
+ * Provides sanitization functions for user input and props.
+ */
+
+/**
+ * Sanitize string by trimming and limiting length
+ */
+export function sanitizeString(str: string | undefined, maxLength: number): string {
+  if (!str) return "";
+  return str.trim().slice(0, maxLength);
+}
+
+/**
+ * Sanitize title prop
+ */
+export function sanitizeTitle(title: string): string {
+  return sanitizeString(title, 200) || "";
+}
+
+/**
+ * Sanitize description prop
+ */
+export function sanitizeDescription(description: string | undefined): string | undefined {
+  return sanitizeString(description || "", 500);
+}
+
+/**
+ * Truncate text with ellipsis
+ */
+export function truncateText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+
+/**
+ * Escape HTML entities (for security)
+ */
+export function escapeHtml(text: string): string {
+  const htmlEntities: Record<string, string> = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+  };
+  return text.replace(/[&<>"']/g, (char) => htmlEntities[char] || char);
+}

package/src/infrastructure/utils/translationHelpers.ts

@@ -0,0 +1,81 @@
+/**
+ * Translation Helper Utilities
+ *
+ * Provides safe translation utilities that handle cases where
+ * the translation function might not be available yet.
+ */
+
+export type TranslationFunction = (key: string, params?: Record<string, string | number>) => string;
+
+/**
+ * Safely get a translation with fallback
+ * @param t Translation function
+ * @param key Translation key
+ * @param fallback Fallback text if translation fails
+ * @returns Translated text or fallback
+ */
+export function getTranslationWithFallback(
+  t: TranslationFunction | unknown,
+  key: string,
+  fallback: string
+): string {
+  if (typeof t === "function") {
+    try {
+      return t(key);
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+
+/**
+ * Get translation with parameters support
+ * @param t Translation function
+ * @param key Translation key
+ * @param params Parameters for translation
+ * @param fallback Fallback text if translation fails
+ * @returns Translated text or fallback
+ */
+export function getTranslationWithParams(
+  t: TranslationFunction | unknown,
+  key: string,
+  params: Record<string, string | number>,
+  fallback: string
+): string {
+  if (typeof t === "function") {
+    try {
+      return t(key, params);
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+
+/**
+ * Check if translation function is available
+ * @param t Translation function to check
+ * @returns true if translation function is available
+ */
+export function isTranslationFunctionAvailable(t: unknown): t is TranslationFunction {
+  return typeof t === "function";
+}
+
+/**
+ * Create a safe translation wrapper that always returns a string
+ * @param t Translation function
+ * @returns Safe translation function
+ */
+export function createSafeTranslator(t: TranslationFunction | unknown): TranslationFunction {
+  return (key: string, params?: Record<string, string | number>) => {
+    if (isTranslationFunctionAvailable(t)) {
+      try {
+        return t(key, params);
+      } catch {
+        return key;
+      }
+    }
+    return key;
+  };
+}

package/src/infrastructure/utils/validators.ts

@@ -0,0 +1,59 @@
+/**
+ * Validation Utilities
+ *
+ * Provides validation functions for component props.
+ */
+
+export interface ValidationWarning {
+  message: string;
+  value: unknown;
+}
+
+/**
+ * Validate settings item title
+ */
+export function validateTitle(title: unknown): ValidationWarning | null {
+  if (!title || typeof title !== "string") {
+    return {
+      message: "[SettingsItemCard] Invalid title prop",
+      value: title,
+    };
+  }
+  return null;
+}
+
+/**
+ * Validate settings item description
+ */
+export function validateDescription(description: unknown): ValidationWarning | null {
+  if (description && typeof description !== "string") {
+    return {
+      message: "[SettingsItemCard] Invalid description prop",
+      value: description,
+    };
+  }
+  return null;
+}
+
+/**
+ * Validate switch props
+ */
+export function validateSwitchProps(
+  showSwitch: boolean,
+  onSwitchChange?: ((value: boolean) => void) | null
+): ValidationWarning | null {
+  if (showSwitch && !onSwitchChange) {
+    return {
+      message: "[SettingsItemCard] Switch shown but no onSwitchChange provided",
+      value: { showSwitch, hasOnSwitchChange: !!onSwitchChange },
+    };
+  }
+  return null;
+}
+
+/**
+ * Return validation result (no logging)
+ */
+export function getValidationResult(warning: ValidationWarning | null): ValidationWarning | null {
+  return warning;
+}