@umituz/react-native-settings 5.4.9 → 5.4.10

package/src/core/utils/validators.ts

@@ -0,0 +1,203 @@
+/**
+ * Common Validators
+ *
+ * Reusable validation functions for domains.
+ * All validators should be pure functions.
+ *
+ * @example
+ * ```ts
+ * import { validators } from '@/core/utils/validators';
+ *
+ * if (!validators.isValidEmail(email)) {
+ *   return { error: 'Invalid email' };
+ * }
+ * ```
+ */
+
+/**
+ * Common validation utilities
+ */
+export const validators = {
+  /**
+   * Check if value is not empty (null, undefined, or empty string)
+   */
+  isNotEmpty: <T>(value: T | null | undefined | ''): value is T => {
+    return value !== null && value !== undefined && value !== '';
+  },
+
+  /**
+   * Check if string is a valid email format
+   */
+  isValidEmail: (email: string): boolean => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  },
+
+  /**
+   * Check if string is a valid URL
+   */
+  isValidUrl: (url: string): boolean => {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+
+  /**
+   * Check if value is within range (inclusive)
+   */
+  isInRange: (value: number, min: number, max: number): boolean => {
+    return value >= min && value <= max;
+  },
+
+  /**
+   * Check if value is a positive number
+   */
+  isPositive: (value: number): boolean => {
+    return value > 0;
+  },
+
+  /**
+   * Check if value is a non-negative number
+   */
+  isNonNegative: (value: number): boolean => {
+    return value >= 0;
+  },
+
+  /**
+   * Check if array has items
+   */
+  hasItems: <T>(array: T[] | readonly T[]): boolean => {
+    return Array.isArray(array) && array.length > 0;
+  },
+
+  /**
+   * Check if value is a valid ISO date string
+   */
+  isValidISODate: (dateString: string): boolean => {
+    if (!dateString) return false;
+    const date = new Date(dateString);
+    return date instanceof Date && !isNaN(date.getTime());
+  },
+
+  /**
+   * Check if date is in the past
+   */
+  isPastDate: (dateString: string): boolean => {
+    const date = new Date(dateString);
+    return date instanceof Date && !isNaN(date.getTime()) && date < new Date();
+  },
+
+  /**
+   * Check if date is in the future
+   */
+  isFutureDate: (dateString: string): boolean => {
+    const date = new Date(dateString);
+    return date instanceof Date && !isNaN(date.getTime()) && date > new Date();
+  },
+
+  /**
+   * Check if object has required properties
+   */
+  hasProperties: <T extends object>(
+    obj: T,
+    properties: (keyof T)[]
+  ): boolean => {
+    return properties.every((prop) => prop in obj);
+  },
+
+  /**
+   * Check if string meets minimum length
+   */
+  hasMinLength: (str: string, min: number): boolean => {
+    return typeof str === 'string' && str.length >= min;
+  },
+
+  /**
+   * Check if string meets maximum length
+   */
+  hasMaxLength: (str: string, max: number): boolean => {
+    return typeof str === 'string' && str.length <= max;
+  },
+
+  /**
+   * Check if value is one of the allowed values
+   */
+  isOneOf: <T>(value: T, allowed: readonly T[]): boolean => {
+    return allowed.includes(value);
+  },
+
+  /**
+   * Check if time is valid (hour: minute)
+   */
+  isValidTime: (hour: number, minute: number): boolean => {
+    return (
+      validators.isInRange(hour, 0, 23) &&
+      validators.isInRange(minute, 0, 59)
+    );
+  },
+
+  /**
+   * Check if time range is valid (start before end)
+   */
+  isValidTimeRange: (
+    startHour: number,
+    startMinute: number,
+    endHour: number,
+    endMinute: number
+  ): boolean => {
+    if (!validators.isValidTime(startHour, startMinute)) return false;
+    if (!validators.isValidTime(endHour, endMinute)) return false;
+
+    const startMinutes = startHour * 60 + startMinute;
+    const endMinutes = endHour * 60 + endMinute;
+
+    // Allow ranges that span midnight (e.g., 22:00 - 06:00)
+    return startMinutes !== endMinutes;
+  },
+};
+
+/**
+ * Validation result type
+ */
+export type ValidationResult<T> =
+  | { valid: true; data: T }
+  | { valid: false; error: string };
+
+/**
+ * Create a validation result
+ */
+export function valid<T>(data: T): ValidationResult<T> {
+  return { valid: true, data };
+}
+
+/**
+ * Create an invalid validation result
+ */
+export function invalid(error: string): ValidationResult<never> {
+  return { valid: false, error };
+}
+
+/**
+ * Chain multiple validations
+ *
+ * @example
+ * ```ts
+ * const result = validateAll(
+ *   validators.isValidEmail(email) || 'Invalid email',
+ *   validators.hasMinLength(email, 5) || 'Email too short'
+ * );
+ * ```
+ */
+export function validateAll(
+  ...checks: (boolean | string)[]
+): ValidationResult<null> {
+  for (const check of checks) {
+    if (check !== true) {
+      return invalid(typeof check === 'string' ? check : 'Validation failed');
+    }
+  }
+  return valid(null);
+}

package/src/domains/disclaimer/index.ts

@@ -18,8 +18,8 @@ export type { DisclaimerSettingProps } from './presentation/components/Disclaime
 export { DisclaimerCard } from './presentation/components/DisclaimerCard';
 export type { DisclaimerCardProps } from './presentation/components/DisclaimerCard';
 
-export { DisclaimerModal } from './presentation/components/DisclaimerModal';
-export type { DisclaimerModalProps } from './presentation/components/DisclaimerModal';
+export { useDisclaimerModal } from './presentation/hooks/useDisclaimerModal';
+export type { DisclaimerModalOptions } from './presentation/hooks/useDisclaimerModal';
 
 // =============================================================================
 // PRESENTATION LAYER - Screens

package/src/domains/disclaimer/presentation/hooks/useDisclaimerModal.ts

@@ -0,0 +1,72 @@
+/**
+ * useDisclaimerModal Hook
+ *
+ * Refactored to use GenericModal and ModalConfig.
+ * Replaces old DisclaimerModal component.
+ *
+ * @example
+ * ```ts
+ * const { DisclaimerModal, showDisclaimer } = useDisclaimerModal();
+ *
+ * return (
+ *   <>
+ *     <Button onPress={() => showDisclaimer({ title: 'Terms', content: '...' })} />
+ *     <DisclaimerModal />
+ *   </>
+ * );
+ * ```
+ */
+
+import { useCallback } from 'react';
+import { GenericModal } from '../../../../presentation/components/GenericModal';
+import { useModalState } from '../../../../core/patterns/Modal/useModalState';
+import type { ModalConfig } from '../../../../core/patterns/Modal/ModalConfig';
+
+export interface DisclaimerModalOptions {
+  /**
+   * Disclaimer title
+   */
+  title: string;
+
+  /**
+   * Disclaimer content
+   */
+  content: string;
+
+  /**
+   * Custom modal configuration
+   */
+  config?: Partial<ModalConfig>;
+}
+
+/**
+ * Disclaimer modal hook
+ */
+export function useDisclaimerModal() {
+  const modal = useModalState();
+
+  const showDisclaimer = useCallback((options: DisclaimerModalOptions) => {
+    const { title, content, config: customConfig } = options;
+
+    const modalConfig: ModalConfig = {
+      title,
+      message: content,
+      dismissible: true,
+      closeOnBackdropPress: true,
+      closeOnBackPress: true,
+      ...customConfig,
+    };
+
+    modal.show(modalConfig);
+  }, [modal]);
+
+  const DisclaimerModal = useCallback(() => {
+    return <GenericModal state={modal} testID="disclaimer-modal" />;
+  }, [modal]);
+
+  return {
+    DisclaimerModal,
+    showDisclaimer,
+    modal,
+  };
+}

package/src/domains/feedback/index.ts

@@ -4,7 +4,8 @@
  */
 
 export * from './presentation/components/FeedbackForm';
-export * from './presentation/components/FeedbackModal';
+export { useFeedbackModal } from './presentation/hooks/useFeedbackModal';
+export type { FeedbackModalOptions } from './presentation/hooks/useFeedbackModal';
 export { SupportSection } from './presentation/components/SupportSection';
 export type { SupportSectionProps, FeedbackModalTexts } from './presentation/components/SupportSection';
 export * from './presentation/hooks/useFeedbackForm';

package/src/domains/feedback/presentation/hooks/useFeedbackModal.ts

@@ -0,0 +1,182 @@
+/**
+ * useFeedbackModal Hook
+ *
+ * Refactored to use GenericModal and ModalConfig.
+ * Replaces old FeedbackModal component.
+ *
+ * @example
+ * ```ts
+ * const { FeedbackModal, showFeedbackModal } = useFeedbackModal();
+ *
+ * return (
+ *   <>
+ *     <Button onPress={() => showFeedbackModal({ onSubmit: ... })} />
+ *     <FeedbackModal />
+ *   </>
+ * );
+ * ```
+ */
+
+import { useCallback, useState } from 'react';
+import { View, TouchableOpacity, StyleSheet } from 'react-native';
+import { BaseModal } from '@umituz/react-native-design-system/molecules';
+import { AtomicText, AtomicIcon } from '@umituz/react-native-design-system/atoms';
+import { ScreenLayout } from '@umituz/react-native-design-system/layouts';
+import { useAppDesignTokens } from '@umituz/react-native-design-system/theme';
+import { FeedbackForm } from '../components/FeedbackForm';
+import type { FeedbackType, FeedbackRating } from '../../domain/entities/FeedbackEntity';
+import type { FeedbackFormProps } from '../components/FeedbackFormProps';
+
+export interface FeedbackModalOptions {
+  /**
+   * Submit callback
+   */
+  onSubmit: (data: {
+    type: FeedbackType;
+    rating: FeedbackRating;
+    description: string;
+    title: string;
+  }) => Promise<void>;
+
+  /**
+   * Initial feedback type
+   */
+  initialType?: FeedbackType;
+
+  /**
+   * Modal title
+   */
+  title?: string;
+
+  /**
+   * Modal subtitle
+   */
+  subtitle?: string;
+
+  /**
+   * Form texts
+   */
+  texts: FeedbackFormProps['texts'];
+
+  /**
+   * Custom configuration
+   */
+  config?: {
+    showHeader?: boolean;
+    showCloseButton?: boolean;
+  };
+}
+
+/**
+ * Feedback modal hook
+ */
+export function useFeedbackModal() {
+  const [visible, setVisible] = useState(false);
+  const [options, setOptions] = useState<FeedbackModalOptions | null>(null);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+
+  const tokens = useAppDesignTokens();
+  const styles = getStyles(tokens);
+
+  const showFeedbackModal = useCallback((newOptions: FeedbackModalOptions) => {
+    setOptions(newOptions);
+    setVisible(true);
+  }, []);
+
+  const hideFeedbackModal = useCallback(() => {
+    setVisible(false);
+    setIsSubmitting(false);
+  }, []);
+
+  const handleSubmit = useCallback(async (data: any) => {
+    if (!options) return;
+
+    setIsSubmitting(true);
+    try {
+      await options.onSubmit(data);
+      hideFeedbackModal();
+    } catch (error) {
+      setIsSubmitting(false);
+    }
+  }, [options, hideFeedbackModal]);
+
+  const header = options?.config?.showHeader !== false ? (
+    <View style={styles.header}>
+      <View style={styles.headerText}>
+        {options?.title && (
+          <AtomicText style={{ fontSize: 20, fontWeight: '600' }}>
+            {options.title}
+          </AtomicText>
+        )}
+        {options?.subtitle && (
+          <AtomicText style={{ fontSize: 14, marginTop: 4 }}>
+            {options.subtitle}
+          </AtomicText>
+        )}
+      </View>
+      {options?.config?.showCloseButton !== false && (
+        <TouchableOpacity
+          onPress={hideFeedbackModal}
+          style={[styles.closeButton, { backgroundColor: tokens.colors.surfaceVariant }]}
+        >
+          <AtomicIcon name="close" size="sm" color="onSurface" />
+        </TouchableOpacity>
+      )}
+    </View>
+  ) : undefined;
+
+  const FeedbackModal = useCallback(() => {
+    if (!options) return null;
+
+    return (
+      <BaseModal visible={visible} onClose={hideFeedbackModal}>
+        <ScreenLayout
+          header={header}
+          scrollable={true}
+          edges={[]}
+          keyboardAvoiding={true}
+          contentContainerStyle={styles.content}
+          hideScrollIndicator={false}
+        >
+          <FeedbackForm
+            onSubmit={handleSubmit}
+            initialType={options.initialType}
+            isSubmitting={isSubmitting}
+            texts={options.texts}
+          />
+        </ScreenLayout>
+      </BaseModal>
+    );
+  }, [visible, options, header, styles, handleSubmit, isSubmitting, hideFeedbackModal]);
+
+  return {
+    FeedbackModal,
+    showFeedbackModal,
+    hideFeedbackModal,
+    isVisible: visible,
+  };
+}
+
+const getStyles = (_tokens: ReturnType<typeof useAppDesignTokens>) =>
+  StyleSheet.create({
+    header: {
+      flexDirection: 'row',
+      justifyContent: 'space-between',
+      alignItems: 'center',
+      padding: 16,
+      borderBottomWidth: 1,
+    },
+    headerText: {
+      flex: 1,
+    },
+    closeButton: {
+      width: 36,
+      height: 36,
+      borderRadius: 18,
+      justifyContent: 'center',
+      alignItems: 'center',
+    },
+    content: {
+      padding: 20,
+    },
+  });

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

@@ -1,14 +1,15 @@
 /**
- * NotificationService
+ * Notification Service
  *
  * Simple facade for offline notification system.
  * Works in ALL apps - offline, online, hybrid - no backend required.
+ * Refactored to extend BaseService.
  *
  * @module NotificationService
  */
 
 import { NotificationManager } from './NotificationManager';
-import { isDev } from '../../../../utils/devUtils';
+import { BaseService } from '../../../../core/base/BaseService';
 
 export * from './types';
 
@@ -16,26 +17,24 @@ export * from './types';
  * Notification service singleton
  * Provides simple access to notification manager
  */
-export class NotificationService {
+export class NotificationService extends BaseService {
+  protected serviceName = 'NotificationService';
   private static instance: NotificationService | null = null;
   private isConfigured = false;
 
   readonly notifications = new NotificationManager();
 
   private constructor() {
+    super();
     // Configuration deferred to first use
   }
 
   private ensureConfigured() {
     if (!this.isConfigured) {
-      try {
+      this.executeUnsafe('ensureConfigured', () => {
         NotificationManager.configure();
         this.isConfigured = true;
-      } catch (error) {
-        if (isDev()) {
-          console.error('[NotificationService] Failed to configure NotificationManager:', error);
-        }
-      }
+      });
     }
   }
 
@@ -51,7 +50,10 @@ export class NotificationService {
    */
   async requestPermissions(): Promise<boolean> {
     this.ensureConfigured();
-    return await this.notifications.requestPermissions();
+    const result = await this.execute('requestPermissions', async () => {
+      return await this.notifications.requestPermissions();
+    });
+    return result.success ? result.data : false;
   }
 
   /**
@@ -59,7 +61,10 @@ export class NotificationService {
    */
   async hasPermissions(): Promise<boolean> {
     this.ensureConfigured();
-    return await this.notifications.hasPermissions();
+    const result = await this.execute('hasPermissions', async () => {
+      return await this.notifications.hasPermissions();
+    });
+    return result.success ? result.data : false;
   }
 }