@umituz/react-native-settings 4.17.14 → 4.17.16

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

@@ -0,0 +1,71 @@
+/**
+ * Tests for UrlHandlerService
+ */
+
+import { UrlHandlerService } from '../domain/services/UrlHandlerService';
+
+describe('UrlHandlerService', () => {
+  beforeEach(() => {
+    UrlHandlerService.clearCache();
+  });
+
+  describe('isValidUrl', () => {
+    it('should return true for valid HTTP URLs', () => {
+      expect(UrlHandlerService['isValidUrl']('http://example.com')).toBe(true);
+      expect(UrlHandlerService['isValidUrl']('https://example.com')).toBe(true);
+    });
+
+    it('should return true for valid mailto URLs', () => {
+      expect(UrlHandlerService['isValidUrl']('mailto:test@example.com')).toBe(true);
+    });
+
+    it('should return true for valid tel URLs', () => {
+      expect(UrlHandlerService['isValidUrl']('tel:+1234567890')).toBe(true);
+    });
+
+    it('should return true for valid FTP URLs', () => {
+      expect(UrlHandlerService['isValidUrl']('ftp://example.com')).toBe(true);
+    });
+
+    it('should return false for invalid URLs', () => {
+      expect(UrlHandlerService['isValidUrl']('')).toBe(false);
+      expect(UrlHandlerService['isValidUrl']('invalid-url')).toBe(false);
+      expect(UrlHandlerService['isValidUrl']('www.example.com')).toBe(false);
+      expect(UrlHandlerService['isValidUrl'](undefined as any)).toBe(false);
+      expect(UrlHandlerService['isValidUrl'](null as any)).toBe(false);
+      expect(UrlHandlerService['isValidUrl'](123 as any)).toBe(false);
+    });
+  });
+
+  describe('canOpenUrl', () => {
+    it('should return false for invalid URLs', async () => {
+      const result = await UrlHandlerService.canOpenUrl('invalid-url');
+      expect(result).toBe(false);
+    });
+
+    it('should cache results', async () => {
+      const mockLinking = {
+        canOpenURL: jest.fn().mockResolvedValue(true)
+      };
+      
+      // Mock the Linking module
+      jest.doMock('react-native', () => ({
+        Linking: mockLinking
+      }));
+
+      const url = 'https://example.com';
+      await UrlHandlerService.canOpenUrl(url);
+      await UrlHandlerService.canOpenUrl(url);
+
+      expect(mockLinking.canOpenURL).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('clearCache', () => {
+    it('should clear all caches', () => {
+      UrlHandlerService.clearCache();
+      // Test passes if no errors are thrown
+      expect(true).toBe(true);
+    });
+  });
+});

package/src/domains/legal/__tests__/setup.ts

@@ -0,0 +1,82 @@
+/**
+ * Jest setup file
+ */
+
+// Mock React Native modules
+jest.mock('react-native', () => ({
+  View: 'View',
+  Text: 'Text',
+  ScrollView: 'ScrollView',
+  TouchableOpacity: 'TouchableOpacity',
+  StyleSheet: {
+    create: jest.fn((styles) => styles),
+  },
+  Linking: {
+    canOpenURL: jest.fn(() => Promise.resolve(true)),
+    openURL: jest.fn(() => Promise.resolve()),
+  },
+  Platform: {
+    OS: 'ios',
+    select: jest.fn((obj) => obj.ios),
+  },
+}));
+
+// Mock design system modules (only if they exist)
+try {
+  jest.mock('@umituz/react-native-design-system', () => ({
+    useAppDesignTokens: jest.fn(() => ({
+      colors: {
+        backgroundPrimary: '#ffffff',
+        primary: '#007AFF',
+        textPrimary: '#000000',
+        textSecondary: '#666666',
+        textTertiary: '#999999',
+        onSurface: '#000000',
+        secondary: '#5856D6',
+        info: '#007AFF',
+      },
+      spacing: {
+        xs: 4,
+        sm: 8,
+        md: 16,
+        lg: 24,
+      },
+    })),
+  }));
+} catch (e) {
+  // Module not found, skip mocking
+}
+
+try {
+  jest.mock('@umituz/react-native-design-system', () => ({
+    AtomicText: 'AtomicText',
+    AtomicIcon: 'AtomicIcon',
+    AtomicButton: 'AtomicButton',
+  }));
+} catch (e) {
+  // Module not found, skip mocking
+}
+
+try {
+  jest.mock('@umituz/react-native-design-system', () => ({
+    ScreenLayout: 'ScreenLayout',
+  }));
+} catch (e) {
+  // Module not found, skip mocking
+}
+
+try {
+  jest.mock('react-native-safe-area-context', () => ({
+    useSafeAreaInsets: jest.fn(() => ({
+      top: 44,
+      bottom: 34,
+      left: 0,
+      right: 0,
+    })),
+  }));
+} catch (e) {
+  // Module not found, skip mocking
+}
+
+// Global test setup
+global.__DEV__ = true;

package/src/domains/legal/domain/entities/LegalConfig.ts

@@ -0,0 +1,26 @@
+/**
+ * Legal Config
+ * Configuration for the Legal section
+ */
+export interface LegalConfig {
+    /** Section title */
+    title?: string;
+    /** Section description */
+    description?: string;
+    /** Navigation route name */
+    route?: string;
+    /** Default navigation route name */
+    defaultRoute?: string;
+    /** Privacy Policy title */
+    privacyTitle?: string;
+    /** Terms of Service title */
+    termsTitle?: string;
+    /** EULA title */
+    eulaTitle?: string;
+    /** Privacy Policy URL */
+    privacyUrl?: string;
+    /** Terms of Service URL */
+    termsUrl?: string;
+    /** EULA URL */
+    eulaUrl?: string;
+}

package/src/domains/legal/domain/services/ContentValidationService.ts

@@ -0,0 +1,89 @@
+/**
+ * Content Validation Service
+ * Single Responsibility: Validate content and URL requirements
+ * Extracted from screens to follow SOLID principles
+ */
+
+export interface ContentValidationRule {
+  content?: string;
+  url?: string;
+  title?: string;
+  viewOnlineText?: string;
+  openText?: string;
+  privacyText?: string;
+  termsText?: string;
+}
+
+export class ContentValidationService {
+  /**
+   * Validate screen content requirements
+   */
+  static validateScreenContent(
+    content: string | undefined,
+    url: string | undefined,
+    title: string | undefined,
+    viewOnlineText: string | undefined,
+    openText: string | undefined,
+    screenName: string
+  ): void {
+    if (__DEV__) {
+      if (!content && !url) {
+        console.warn(`${screenName}: Either content or url must be provided`);
+      }
+      if (!title) {
+        console.warn(`${screenName}: title is required`);
+      }
+      if (url && !viewOnlineText) {
+        console.warn(`${screenName}: viewOnlineText is required when url is provided`);
+      }
+      if (url && !openText) {
+        console.warn(`${screenName}: openText is required when url is provided`);
+      }
+    }
+  }
+
+  /**
+   * Validate legal links requirements
+   */
+  static validateLegalLinks(
+    privacyPolicyUrl: string | undefined,
+    termsOfServiceUrl: string | undefined,
+    privacyText: string | undefined,
+    termsText: string | undefined,
+    onPrivacyPress: (() => void) | undefined,
+    onTermsPress: (() => void) | undefined
+  ): void {
+    if (__DEV__) {
+      if (privacyPolicyUrl && !privacyText && !onPrivacyPress) {
+        console.warn('LegalLinks: privacyText is required when privacyPolicyUrl is provided');
+      }
+      if (termsOfServiceUrl && !termsText && !onTermsPress) {
+        console.warn('LegalLinks: termsText is required when termsOfServiceUrl is provided');
+      }
+    }
+  }
+
+  /**
+   * Check if content is valid
+   */
+  static hasValidContent(content?: string, url?: string): boolean {
+    return !!(content || url);
+  }
+
+  /**
+   * Check if URL section should be shown
+   */
+  static shouldShowUrlSection(url?: string, onUrlPress?: () => void): boolean {
+    return !!(url || onUrlPress);
+  }
+
+  /**
+   * Check if legal item should be shown
+   */
+  static shouldShowLegalItem(
+    onPress?: () => void,
+    title?: string
+  ): boolean {
+    return !!(onPress && title);
+  }
+}

package/src/domains/legal/domain/services/StyleCacheService.ts

@@ -0,0 +1,97 @@
+/**
+ * Style Cache Service
+ * Single Responsibility: Manage style caching to prevent memory leaks
+ * Extracted from components to follow SOLID principles
+ */
+
+import type { DesignTokens } from "@umituz/react-native-design-system";
+
+export interface StyleCacheOptions {
+  maxSize?: number;
+  cacheKey?: string;
+}
+
+export class StyleCacheService {
+  private static caches = new Map<string, Map<string, any>>();
+  private static readonly DEFAULT_MAX_SIZE = 50;
+
+  /**
+   * Get or create cached styles
+   */
+  static getCachedStyles<T>(
+    cacheName: string,
+    cacheKey: string,
+    styleFactory: () => T,
+    maxSize: number = this.DEFAULT_MAX_SIZE
+  ): T {
+    let cache = this.caches.get(cacheName);
+    
+    if (!cache) {
+      cache = new Map();
+      this.caches.set(cacheName, cache);
+    }
+
+    // Check if styles already cached
+    if (cache.has(cacheKey)) {
+      return cache.get(cacheKey);
+    }
+
+    // Create new styles and cache them
+    const styles = styleFactory();
+    
+    // Limit cache size to prevent memory leaks
+    if (cache.size > maxSize) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey) {
+        cache.delete(firstKey);
+      }
+    }
+    
+    cache.set(cacheKey, styles);
+    return styles;
+  }
+
+  /**
+   * Clear specific cache
+   */
+  static clearCache(cacheName: string): void {
+    this.caches.delete(cacheName);
+  }
+
+  /**
+   * Clear all caches
+   */
+  static clearAllCaches(): void {
+    this.caches.clear();
+  }
+
+  /**
+   * Get cache size
+   */
+  static getCacheSize(cacheName: string): number {
+    const cache = this.caches.get(cacheName);
+    return cache ? cache.size : 0;
+  }
+
+  /**
+   * Create cache key from design tokens
+   */
+  static createTokenCacheKey(tokens: DesignTokens, additionalKeys?: Record<string, any>): string {
+    const tokenData = {
+      xs: tokens.spacing.xs,
+      sm: tokens.spacing.sm,
+      md: tokens.spacing.md,
+      lg: tokens.spacing.lg,
+      ...additionalKeys
+    };
+    
+    return JSON.stringify(tokenData);
+  }
+
+  /**
+   * Create simple cache key
+   */
+  static createSimpleCacheKey(key: string): string {
+    return key;
+  }
+}

package/src/domains/legal/domain/services/UrlHandlerService.ts

@@ -0,0 +1,128 @@
+/**
+ * URL Handler Service
+ * Single Responsibility: Handle URL operations
+ * Extracted from screens to follow SOLID principles
+ * Performance optimized with caching and error handling
+ */
+
+import { Linking } from 'react-native';
+
+// URL validation cache to avoid repeated checks
+const urlValidationCache = new Map<string, boolean>();
+const MAX_CACHE_SIZE = 100;
+
+export class UrlHandlerService {
+  /**
+   * Get Linking module - using static import for stability
+   */
+  private static getLinkingModule(): any {
+    return Linking;
+  }
+
+  /**
+   * Clean cache to prevent memory leaks
+   */
+  private static cleanCache(): void {
+    if (urlValidationCache.size > MAX_CACHE_SIZE) {
+      const entriesToDelete = Array.from(urlValidationCache.keys()).slice(0, Math.floor(MAX_CACHE_SIZE / 2));
+      entriesToDelete.forEach(key => urlValidationCache.delete(key));
+    }
+  }
+
+  /**
+   * Validate URL format to prevent invalid operations
+   */
+  private static isValidUrl(url: string): boolean {
+    if (!url || typeof url !== 'string') return false;
+
+    try {
+      // Basic URL validation without creating URL object to avoid memory overhead
+      return url.startsWith('http://') ||
+        url.startsWith('https://') ||
+        url.startsWith('mailto:') ||
+        url.startsWith('tel:') ||
+        url.startsWith('ftp://');
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Open URL in external browser with performance optimizations
+   */
+  static async openUrl(url: string): Promise<void> {
+    if (__DEV__) {
+      console.log('UrlHandlerService: Opening URL', { url });
+    }
+
+    if (!this.isValidUrl(url)) {
+      if (__DEV__) {
+        console.warn('UrlHandlerService: Invalid URL provided', { url });
+      }
+      return;
+    }
+
+    try {
+      const Linking = await this.getLinkingModule();
+
+      // Check cache first to avoid repeated canOpenURL calls
+      let canOpen = urlValidationCache.get(url);
+      if (canOpen === undefined) {
+        canOpen = await Linking.canOpenURL(url);
+
+        // Cache the result with size limit
+        this.cleanCache();
+        urlValidationCache.set(url, canOpen || false);
+      }
+
+      if (canOpen) {
+        await Linking.openURL(url);
+      } else {
+        if (__DEV__) {
+          console.warn('UrlHandlerService: Cannot open URL', { url });
+        }
+      }
+    } catch (error) {
+      if (__DEV__) {
+        console.error('UrlHandlerService: Error opening URL', { url, error });
+      }
+      // Don't throw error to prevent app crashes, just log it
+    }
+  }
+
+  /**
+   * Check if URL can be opened with caching
+   */
+  static async canOpenUrl(url: string): Promise<boolean> {
+    if (!this.isValidUrl(url)) return false;
+
+    // Check cache first
+    const cached = urlValidationCache.get(url);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    try {
+      const Linking = await this.getLinkingModule();
+      const canOpen = await Linking.canOpenURL(url);
+
+      // Cache the result with size limit
+      this.cleanCache();
+      urlValidationCache.set(url, canOpen);
+
+      return canOpen;
+    } catch {
+      // Cache failure to prevent repeated attempts
+      this.cleanCache();
+      urlValidationCache.set(url, false);
+      return false;
+    }
+  }
+
+  /**
+   * Clear all caches (useful for testing or memory cleanup)
+   */
+  static clearCache(): void {
+    urlValidationCache.clear();
+  }
+}

package/src/domains/legal/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Legal Domain
+ * Terms, privacy policy, licenses
+ */
+
+export * from './presentation/screens/LegalScreen';
+export * from './presentation/screens/PrivacyPolicyScreen';
+export * from './presentation/screens/TermsOfServiceScreen';

package/src/domains/legal/presentation/components/LegalItem.tsx

@@ -0,0 +1,177 @@
+/**
+ * LegalItem Component
+ * 
+ * Single Responsibility: Display a single legal document item
+ * Reusable component for Privacy Policy, Terms of Service, and EULA items
+ */
+
+import React from "react";
+import { View, StyleSheet, TouchableOpacity } from "react-native";
+import { useResponsiveDesignTokens, type DesignTokens } from "@umituz/react-native-design-system";
+import { AtomicText, AtomicIcon } from "@umituz/react-native-design-system";
+import type { IconName } from "@umituz/react-native-design-system";
+import { StyleCacheService } from "../../domain/services/StyleCacheService";
+
+export interface LegalItemProps {
+  /**
+   * Icon name from Lucide library (e.g., "Shield", "FileText", "ScrollText")
+   * If not provided, will use emoji icon
+   */
+  iconName?: IconName;
+  /**
+   * Icon emoji or text (fallback if iconName not provided)
+   */
+  icon?: string;
+  /**
+   * Title text
+   */
+  title: string;
+  /**
+   * Optional description text
+   */
+  description?: string;
+  /**
+   * Callback when item is pressed
+   */
+  onPress?: () => void;
+  /**
+   * Test ID for E2E testing
+   */
+  testID?: string;
+}
+
+export const LegalItem: React.FC<LegalItemProps> = React.memo(({
+  iconName,
+  icon,
+  title,
+  description,
+  onPress,
+  testID,
+}) => {
+  const tokens = useResponsiveDesignTokens();
+  
+  // Memoize styles to prevent recreation on every render
+  const styles = React.useMemo(() => {
+    const cacheKey = StyleCacheService.createTokenCacheKey(tokens);
+    return StyleCacheService.getCachedStyles(
+      'LegalItem',
+      cacheKey,
+      () => createLegalItemStyles(tokens)
+    );
+  }, [tokens]);
+
+  // Memoize icon rendering to prevent unnecessary re-renders
+  const renderIcon = React.useCallback(() => {
+    if (iconName) {
+      return (
+        <AtomicIcon
+          name={iconName}
+          size="md"
+          color="info"
+        />
+      );
+    }
+    if (icon) {
+      return (
+        <AtomicText type="bodyLarge" color="info">
+          {icon}
+        </AtomicText>
+      );
+    }
+    return null;
+  }, [iconName, icon]);
+
+  // Memoize icon container style to prevent object creation
+  const iconContainerStyle = React.useMemo(() => [
+    styles.iconContainer, 
+    { backgroundColor: tokens.colors.info + "20" }
+  ], [styles.iconContainer, tokens.colors.info]);
+
+  // Memoize content to prevent unnecessary re-renders
+  const content = React.useMemo(() => (
+    <View style={styles.itemContent}>
+      <View style={styles.itemLeft}>
+        <View style={iconContainerStyle}>
+          {renderIcon()}
+        </View>
+        <View style={styles.itemText}>
+          <AtomicText type="bodyLarge" color="textPrimary">
+            {title}
+          </AtomicText>
+          {description && (
+            <AtomicText
+              type="bodySmall"
+              color="textSecondary"
+              style={styles.itemDescription}
+            >
+              {description}
+            </AtomicText>
+          )}
+        </View>
+      </View>
+      {onPress && (
+        <AtomicText type="bodyMedium" color="textSecondary">›</AtomicText>
+      )}
+    </View>
+  ), [styles.itemContent, styles.itemLeft, styles.itemText, styles.itemDescription, iconContainerStyle, renderIcon, title, description, onPress]);
+
+  // Memoize press handler to prevent child re-renders
+  const handlePress = React.useCallback(() => {
+    onPress?.();
+  }, [onPress]);
+
+  if (onPress) {
+    return (
+      <TouchableOpacity
+        style={styles.itemContainer}
+        onPress={handlePress}
+        testID={testID}
+        activeOpacity={0.7}
+      >
+        {content}
+      </TouchableOpacity>
+    );
+  }
+
+  return (
+    <View style={styles.itemContainer} testID={testID}>
+      {content}
+    </View>
+  );
+});
+
+const createLegalItemStyles = (tokens: DesignTokens) => {
+  return StyleSheet.create({
+    itemContainer: {
+      marginBottom: tokens.spacing.xs,
+    },
+    itemContent: {
+      flexDirection: "row",
+      alignItems: "center",
+      justifyContent: "space-between",
+      paddingHorizontal: tokens.spacing.md,
+      paddingVertical: tokens.spacing.md,
+      minHeight: 64,
+    },
+    itemLeft: {
+      flexDirection: "row",
+      alignItems: "center",
+      flex: 1,
+    },
+    iconContainer: {
+      width: 44,
+      height: 44,
+      borderRadius: 22,
+      alignItems: "center",
+      justifyContent: "center",
+      marginRight: tokens.spacing.md,
+    },
+    itemText: {
+      flex: 1,
+    },
+    itemDescription: {
+      marginTop: tokens.spacing.xs,
+    },
+  });
+};
+