@umituz/react-native-settings 4.17.14 → 4.17.16

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

@@ -0,0 +1,160 @@
+/**
+ * Support Section Component
+ * Renders Support entry points: Feedback and Rating
+ * Agnostic of UI implementation via render props
+ */
+
+import React, { useState, useCallback } from "react";
+import { Linking } from "react-native";
+import { FeedbackModal } from "./FeedbackModal";
+import type { FeedbackType } from "../../domain/entities/FeedbackEntity";
+
+export interface FeedbackConfig {
+    enabled?: boolean;
+    title?: string;
+    description?: string;
+    initialType?: FeedbackType;
+    onSubmit?: (data: { type: any; rating: number; description: string; title: string }) => Promise<void>;
+}
+
+export interface RatingConfig {
+    enabled?: boolean;
+    title?: string;
+    description?: string;
+    storeUrl?: string;
+    onRate?: () => void;
+}
+
+export interface FeedbackModalTexts {
+    title?: string;
+    ratingLabel?: string;
+    descriptionPlaceholder?: string;
+    submitButton?: string;
+    submittingButton?: string;
+    feedbackTypes?: Array<{ type: FeedbackType; label: string }>;
+    defaultTitle?: (type: FeedbackType) => string;
+}
+
+export interface SupportSectionProps {
+    feedbackConfig: { enabled: boolean; config?: FeedbackConfig };
+    ratingConfig: { enabled: boolean; config?: RatingConfig };
+    renderSection: (props: { title: string; children: React.ReactNode }) => React.ReactElement | null;
+    renderItem: (props: {
+        title: string;
+        icon: any;
+        onPress: () => void;
+        isLast?: boolean
+    }) => React.ReactElement | null;
+    /** Texts for the feedback modal */
+    feedbackModalTexts?: FeedbackModalTexts;
+}
+
+export const SupportSection: React.FC<SupportSectionProps> = ({
+    feedbackConfig,
+    ratingConfig,
+    renderSection,
+    renderItem,
+    feedbackModalTexts
+}) => {
+    const [modalVisible, setModalVisible] = useState(false);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+
+    const handleFeedbackSubmit = async (data: { type: any; rating: number; description: string; title: string }) => {
+        if (feedbackConfig.config?.onSubmit) {
+            setIsSubmitting(true);
+            try {
+                await feedbackConfig.config.onSubmit(data);
+                setModalVisible(false);
+            } catch (error) {
+                if (__DEV__) {
+                    console.error("Feedback submission error:", error);
+                }
+            } finally {
+                setIsSubmitting(false);
+            }
+        } else {
+            if (__DEV__) {
+                console.warn("No onSubmit handler provided for Feedback");
+            }
+            setModalVisible(false);
+        }
+    };
+
+    const handleRateApp = useCallback(async () => {
+        const config = ratingConfig.config;
+        if (config?.onRate) {
+            config.onRate();
+            return;
+        }
+
+        if (config?.storeUrl) {
+            const supported = await Linking.canOpenURL(config.storeUrl);
+            if (supported) {
+                await Linking.openURL(config.storeUrl);
+            } else {
+                if (__DEV__) {
+                    console.warn("Cannot open store URL:", config.storeUrl);
+                }
+            }
+        } else {
+            if (__DEV__) {
+                console.warn("No storeUrl or onRate provided for Rating");
+            }
+        }
+    }, [ratingConfig.config]);
+
+    const showFeedback = feedbackConfig.enabled;
+    const showRating = ratingConfig.enabled;
+
+    if (!showFeedback && !showRating) return null;
+
+    // Use provided titles, no hardcoded defaults
+    const sectionTitle = (showFeedback && feedbackConfig.config?.title) || (showRating && ratingConfig.config?.title);
+
+    // If no section title provided, don't render
+    if (!sectionTitle) return null;
+
+    return (
+        <>
+            {renderSection({
+                title: sectionTitle,
+                children: (
+                    <>
+                        {showFeedback && feedbackConfig.config?.description && renderItem({
+                            title: feedbackConfig.config.description,
+                            icon: "mail-outline",
+                            onPress: () => setModalVisible(true),
+                            isLast: !showRating
+                        })}
+
+                        {showRating && ratingConfig.config?.description && renderItem({
+                            title: ratingConfig.config.description,
+                            icon: "star-outline",
+                            onPress: handleRateApp,
+                            isLast: true
+                        })}
+                    </>
+                )
+            })}
+
+            {showFeedback && feedbackModalTexts && (
+                <FeedbackModal
+                    visible={modalVisible}
+                    onClose={() => setModalVisible(false)}
+                    onSubmit={handleFeedbackSubmit}
+                    initialType={feedbackConfig.config?.initialType}
+                    isSubmitting={isSubmitting}
+                    title={feedbackModalTexts.title}
+                    texts={{
+                        ratingLabel: feedbackModalTexts.ratingLabel,
+                        descriptionPlaceholder: feedbackModalTexts.descriptionPlaceholder,
+                        submitButton: feedbackModalTexts.submitButton,
+                        submittingButton: feedbackModalTexts.submittingButton,
+                        feedbackTypes: feedbackModalTexts.feedbackTypes,
+                        defaultTitle: feedbackModalTexts.defaultTitle,
+                    }}
+                />
+            )}
+        </>
+    );
+};

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

@@ -0,0 +1,25 @@
+/**
+ * Delete Feedback Hook
+ */
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import type { IFeedbackRepository } from '../../domain/repositories/IFeedbackRepository';
+
+export function useDeleteFeedback(repository: IFeedbackRepository) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (feedbackId: string) => {
+      const result = await repository.deleteFeedback(feedbackId);
+
+      if (!result.success) {
+        throw new Error(result.error.message);
+      }
+
+      return result.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['feedback'] });
+    },
+  });
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Feedback Form Hook
+ */
+
+import { useState, useCallback } from 'react';
+import type { FeedbackType, FeedbackRating } from '../../domain/entities/FeedbackEntity';
+
+export interface FeedbackFormState {
+  type: FeedbackType;
+  title: string;
+  description: string;
+  rating?: FeedbackRating;
+}
+
+const initialState: FeedbackFormState = {
+  type: 'general',
+  title: '',
+  description: '',
+  rating: undefined,
+};
+
+export function useFeedbackForm(defaultValues?: Partial<FeedbackFormState>) {
+  const [formState, setFormState] = useState<FeedbackFormState>({
+    ...initialState,
+    ...defaultValues,
+  });
+
+  const setType = useCallback((type: FeedbackType) => {
+    setFormState((prev) => ({ ...prev, type }));
+  }, []);
+
+  const setTitle = useCallback((title: string) => {
+    setFormState((prev) => ({ ...prev, title }));
+  }, []);
+
+  const setDescription = useCallback((description: string) => {
+    setFormState((prev) => ({ ...prev, description }));
+  }, []);
+
+  const setRating = useCallback((rating: FeedbackRating | undefined) => {
+    setFormState((prev) => ({ ...prev, rating }));
+  }, []);
+
+  const reset = useCallback(() => {
+    setFormState({ ...initialState, ...defaultValues });
+  }, [defaultValues]);
+
+  const isValid = formState.title.trim().length > 0 && formState.description.trim().length > 0;
+
+  return {
+    formState,
+    setType,
+    setTitle,
+    setDescription,
+    setRating,
+    reset,
+    isValid,
+  };
+}

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

@@ -0,0 +1,55 @@
+/**
+ * Submit Feedback Hook
+ */
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import type { IFeedbackRepository } from '../../domain/repositories/IFeedbackRepository';
+import {
+  createFeedback,
+  type FeedbackType,
+} from '../../domain/entities/FeedbackEntity';
+
+interface SubmitFeedbackParams {
+  userId: string | null;
+  userEmail?: string | null;
+  type: FeedbackType;
+  title: string;
+  description: string;
+  rating?: 1 | 2 | 3 | 4 | 5;
+  deviceInfo?: {
+    platform: string;
+    osVersion: string;
+    appVersion: string;
+  };
+  metadata?: Record<string, unknown>;
+}
+
+export function useSubmitFeedback(repository: IFeedbackRepository) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (params: SubmitFeedbackParams) => {
+      const feedback = createFeedback(
+        params.userId,
+        params.type,
+        params.title,
+        params.description,
+        params.userEmail,
+        params.rating,
+        params.deviceInfo,
+        params.metadata
+      );
+
+      const result = await repository.submitFeedback(feedback);
+
+      if (!result.success) {
+        throw new Error(result.error.message);
+      }
+
+      return result.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['feedback'] });
+    },
+  });
+}

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

@@ -0,0 +1,29 @@
+/**
+ * User Feedback Hook
+ */
+
+import { useQuery } from '@tanstack/react-query';
+import type { IFeedbackRepository } from '../../domain/repositories/IFeedbackRepository';
+
+export function useUserFeedback(
+  repository: IFeedbackRepository,
+  userId: string | null
+) {
+  return useQuery({
+    queryKey: ['feedback', userId],
+    queryFn: async () => {
+      if (!userId) {
+        return [];
+      }
+
+      const result = await repository.getUserFeedback(userId);
+
+      if (!result.success) {
+        throw new Error(result.error.message);
+      }
+
+      return result.data;
+    },
+    enabled: !!userId,
+  });
+}

package/src/domains/legal/__tests__/ContentValidationService.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Tests for ContentValidationService
+ */
+
+import { ContentValidationService } from '../domain/services/ContentValidationService';
+
+describe('ContentValidationService', () => {
+  describe('validateScreenContent', () => {
+    const originalWarn = console.warn;
+    const mockWarn = jest.fn();
+
+    beforeEach(() => {
+      mockWarn.mockClear();
+      console.warn = mockWarn;
+    });
+
+    afterEach(() => {
+      console.warn = originalWarn;
+    });
+
+    it('should warn when neither content nor url is provided', () => {
+      ContentValidationService.validateScreenContent(
+        undefined,
+        undefined,
+        'Test Title',
+        'View Online',
+        'Open',
+        'TestScreen'
+      );
+
+      expect(mockWarn).toHaveBeenCalledWith(
+        'TestScreen: Either content or url must be provided'
+      );
+    });
+
+    it('should warn when title is not provided', () => {
+      ContentValidationService.validateScreenContent(
+        'Some content',
+        undefined,
+        undefined,
+        'View Online',
+        'Open',
+        'TestScreen'
+      );
+
+      expect(mockWarn).toHaveBeenCalledWith(
+        'TestScreen: title is required'
+      );
+    });
+
+    it('should warn when url is provided but viewOnlineText is missing', () => {
+      ContentValidationService.validateScreenContent(
+        undefined,
+        'https://example.com',
+        'Test Title',
+        undefined,
+        'Open',
+        'TestScreen'
+      );
+
+      expect(mockWarn).toHaveBeenCalledWith(
+        'TestScreen: viewOnlineText is required when url is provided'
+      );
+    });
+
+    it('should warn when url is provided but openText is missing', () => {
+      ContentValidationService.validateScreenContent(
+        undefined,
+        'https://example.com',
+        'Test Title',
+        'View Online',
+        undefined,
+        'TestScreen'
+      );
+
+      expect(mockWarn).toHaveBeenCalledWith(
+        'TestScreen: openText is required when url is provided'
+      );
+    });
+
+    it('should not warn when all required props are provided', () => {
+      ContentValidationService.validateScreenContent(
+        'Some content',
+        undefined,
+        'Test Title',
+        'View Online',
+        'Open',
+        'TestScreen'
+      );
+
+      expect(mockWarn).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('validateLegalLinks', () => {
+    const originalWarn = console.warn;
+    const mockWarn = jest.fn();
+
+    beforeEach(() => {
+      mockWarn.mockClear();
+      console.warn = mockWarn;
+    });
+
+    afterEach(() => {
+      console.warn = originalWarn;
+    });
+
+    it('should warn when privacyPolicyUrl is provided but privacyText is missing', () => {
+      ContentValidationService.validateLegalLinks(
+        'https://privacy.com',
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      );
+
+      expect(mockWarn).toHaveBeenCalledWith(
+        'LegalLinks: privacyText is required when privacyPolicyUrl is provided'
+      );
+    });
+
+    it('should warn when termsOfServiceUrl is provided but termsText is missing', () => {
+      ContentValidationService.validateLegalLinks(
+        undefined,
+        'https://terms.com',
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      );
+
+      expect(mockWarn).toHaveBeenCalledWith(
+        'LegalLinks: termsText is required when termsOfServiceUrl is provided'
+      );
+    });
+
+    it('should not warn when onPrivacyPress is provided instead of privacyText', () => {
+      const onPrivacyPress = jest.fn();
+      
+      ContentValidationService.validateLegalLinks(
+        'https://privacy.com',
+        undefined,
+        undefined,
+        undefined,
+        onPrivacyPress,
+        undefined
+      );
+
+      expect(mockWarn).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('hasValidContent', () => {
+    it('should return true when content is provided', () => {
+      expect(ContentValidationService.hasValidContent('Some content')).toBe(true);
+    });
+
+    it('should return true when url is provided', () => {
+      expect(ContentValidationService.hasValidContent(undefined, 'https://example.com')).toBe(true);
+    });
+
+    it('should return false when neither content nor url is provided', () => {
+      expect(ContentValidationService.hasValidContent()).toBe(false);
+    });
+  });
+
+  describe('shouldShowUrlSection', () => {
+    it('should return true when url is provided', () => {
+      expect(ContentValidationService.shouldShowUrlSection('https://example.com')).toBe(true);
+    });
+
+    it('should return true when onUrlPress is provided', () => {
+      expect(ContentValidationService.shouldShowUrlSection(undefined, jest.fn())).toBe(true);
+    });
+
+    it('should return false when neither url nor onUrlPress is provided', () => {
+      expect(ContentValidationService.shouldShowUrlSection()).toBe(false);
+    });
+  });
+
+  describe('shouldShowLegalItem', () => {
+    it('should return true when both onPress and title are provided', () => {
+      expect(ContentValidationService.shouldShowLegalItem(jest.fn(), 'Title')).toBe(true);
+    });
+
+    it('should return false when onPress is missing', () => {
+      expect(ContentValidationService.shouldShowLegalItem(undefined, 'Title')).toBe(false);
+    });
+
+    it('should return false when title is missing', () => {
+      expect(ContentValidationService.shouldShowLegalItem(jest.fn())).toBe(false);
+    });
+  });
+});

package/src/domains/legal/__tests__/StyleCacheService.test.ts

@@ -0,0 +1,110 @@
+/**
+ * Tests for StyleCacheService
+ */
+
+import { StyleCacheService } from '../domain/services/StyleCacheService';
+
+describe('StyleCacheService', () => {
+  beforeEach(() => {
+    StyleCacheService.clearAllCaches();
+  });
+
+  describe('getCachedStyles', () => {
+    it('should cache and return styles', () => {
+      const styleFactory = () => ({ test: 'style' });
+      const result1 = StyleCacheService.getCachedStyles('test', 'key1', styleFactory);
+      const result2 = StyleCacheService.getCachedStyles('test', 'key1', styleFactory);
+
+      expect(result1).toEqual({ test: 'style' });
+      expect(result1).toBe(result2); // Should be the same reference
+    });
+
+    it('should create new styles for different keys', () => {
+      const styleFactory = () => ({ test: 'style' });
+      const result1 = StyleCacheService.getCachedStyles('test', 'key1', styleFactory);
+      const result2 = StyleCacheService.getCachedStyles('test', 'key2', styleFactory);
+
+      expect(result1).toEqual(result2);
+      expect(result1).not.toBe(result2); // Should be different references
+    });
+
+    it('should limit cache size', () => {
+      const styleFactory = (index: number) => ({ test: `style${index}` });
+      const maxSize = 3;
+
+      // Fill cache beyond max size
+      for (let i = 0; i < maxSize + 2; i++) {
+        StyleCacheService.getCachedStyles('test', `key${i}`, () => styleFactory(i), maxSize);
+      }
+
+      // Cache should be at most maxSize + 1 (since cleanup happens after adding)
+      expect(StyleCacheService.getCacheSize('test')).toBeLessThanOrEqual(maxSize + 1);
+    });
+  });
+
+  describe('clearCache', () => {
+    it('should clear specific cache', () => {
+      const styleFactory = () => ({ test: 'style' });
+      StyleCacheService.getCachedStyles('test1', 'key1', styleFactory);
+      StyleCacheService.getCachedStyles('test2', 'key1', styleFactory);
+
+      expect(StyleCacheService.getCacheSize('test1')).toBe(1);
+      expect(StyleCacheService.getCacheSize('test2')).toBe(1);
+
+      StyleCacheService.clearCache('test1');
+
+      expect(StyleCacheService.getCacheSize('test1')).toBe(0);
+      expect(StyleCacheService.getCacheSize('test2')).toBe(1);
+    });
+  });
+
+  describe('clearAllCaches', () => {
+    it('should clear all caches', () => {
+      const styleFactory = () => ({ test: 'style' });
+      StyleCacheService.getCachedStyles('test1', 'key1', styleFactory);
+      StyleCacheService.getCachedStyles('test2', 'key1', styleFactory);
+
+      expect(StyleCacheService.getCacheSize('test1')).toBe(1);
+      expect(StyleCacheService.getCacheSize('test2')).toBe(1);
+
+      StyleCacheService.clearAllCaches();
+
+      expect(StyleCacheService.getCacheSize('test1')).toBe(0);
+      expect(StyleCacheService.getCacheSize('test2')).toBe(0);
+    });
+  });
+
+  describe('createTokenCacheKey', () => {
+    it('should create cache key from design tokens', () => {
+      const tokens = {
+        colors: { backgroundPrimary: '#fff', primary: '#000', textPrimary: '#333', textSecondary: '#666', textTertiary: '#999', onSurface: '#111', secondary: '#555', info: '#00f' },
+        spacing: { xs: 4, sm: 8, md: 16, lg: 24 }
+      };
+
+      const key1 = StyleCacheService.createTokenCacheKey(tokens);
+      const key2 = StyleCacheService.createTokenCacheKey(tokens);
+
+      expect(key1).toBe(key2);
+      expect(typeof key1).toBe('string');
+    });
+
+    it('should include additional keys in cache key', () => {
+      const tokens = {
+        colors: { backgroundPrimary: '#fff', primary: '#000', textPrimary: '#333', textSecondary: '#666', textTertiary: '#999', onSurface: '#111', secondary: '#555', info: '#00f' },
+        spacing: { xs: 4, sm: 8, md: 16, lg: 24 }
+      };
+
+      const key1 = StyleCacheService.createTokenCacheKey(tokens, { extra: 'value' });
+      const key2 = StyleCacheService.createTokenCacheKey(tokens, { extra: 'different' });
+
+      expect(key1).not.toBe(key2);
+    });
+  });
+
+  describe('createSimpleCacheKey', () => {
+    it('should create simple cache key', () => {
+      const key = StyleCacheService.createSimpleCacheKey('test-key');
+      expect(key).toBe('test-key');
+    });
+  });
+});