@umituz/react-native-settings 4.17.14 → 4.17.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/react-native-settings",
-  "version": "4.17.14",
-  "description": "Settings management for React Native apps - user preferences, theme, language, notifications",
+  "version": "4.17.16",
+  "description": "Complete settings hub for React Native apps - consolidated package with settings, about, legal, appearance, feedback, and FAQs",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
@@ -18,7 +18,13 @@
     "user-settings",
     "theme",
     "language",
-    "notifications"
+    "notifications",
+    "about",
+    "legal",
+    "appearance",
+    "feedback",
+    "faqs",
+    "consolidated"
   ],
   "author": "Ümit UZ <umit@umituz.com>",
   "license": "MIT",
@@ -30,13 +36,9 @@
     "@expo/vector-icons": ">=14.0.0",
     "@react-navigation/native": ">=6.0.0",
     "@react-navigation/stack": ">=6.0.0",
-    "@umituz/react-native-about": "latest",
-    "@umituz/react-native-appearance": "latest",
     "@umituz/react-native-auth": "latest",
     "@umituz/react-native-avatar": "latest",
-    "@umituz/react-native-faqs": "latest",
-    "@umituz/react-native-feedback": "latest",
-    "@umituz/react-native-legal": "latest",
+    "@umituz/react-native-design-system": "latest",
     "@umituz/react-native-localization": "latest",
     "@umituz/react-native-notifications": "latest",
     "@umituz/react-native-onboarding": "latest",
@@ -53,13 +55,9 @@
     "@expo/vector-icons": "^15.0.0",
     "@types/jest": "^29.5.14",
     "@types/react": "~19.1.10",
-    "@umituz/react-native-about": "latest",
-    "@umituz/react-native-appearance": "latest",
     "@umituz/react-native-auth": "latest",
     "@umituz/react-native-avatar": "latest",
-    "@umituz/react-native-faqs": "latest",
-    "@umituz/react-native-feedback": "latest",
-    "@umituz/react-native-legal": "latest",
+    "@umituz/react-native-design-system": "latest",
     "@umituz/react-native-localization": "latest",
     "@umituz/react-native-notifications": "latest",
     "@umituz/react-native-onboarding": "latest",
@@ -76,5 +74,8 @@
     "src",
     "README.md",
     "LICENSE"
-  ]
-}
+  ],
+  "dependencies": {
+    "@umituz/react-native-design-system": "^2.2.0"
+  }
+}

package/src/domains/about/__tests__/integration.test.tsx

@@ -0,0 +1,328 @@
+/**
+ * Integration tests for the entire About package
+ */
+import '../types/global.d.ts';
+import './types.d.ts';
+import React from 'react';
+import { View, Text } from 'react-native';
+import { render, waitFor, fireEvent } from '@testing-library/react';
+import { AboutScreen } from '../presentation/screens/AboutScreen';
+import { AboutConfig } from '../domain/entities/AppInfo';
+
+// Mock console methods
+const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation();
+const mockConsoleError = jest.spyOn(console, 'error').mockImplementation();
+
+describe('About Package Integration', () => {
+  const fullConfig: AboutConfig = {
+    appInfo: {
+      name: 'Integration Test App',
+      version: '2.0.0',
+      description: 'This is an integration test app',
+      developer: 'Test Developer',
+      contactEmail: 'integration@test.com',
+      websiteUrl: 'https://integration.example.com',
+      websiteDisplay: 'integration.example.com',
+      moreAppsUrl: 'https://apps.integration.example.com',
+    },
+    theme: {
+      primary: '#FF0000',
+      secondary: '#00FF00',
+      background: '#0000FF',
+      text: '#FFFFFF',
+      border: '#CCCCCC',
+    },
+    style: {
+      containerStyle: { backgroundColor: '#f0f0f0' },
+      itemStyle: { padding: 20 },
+      textStyle: { fontSize: 18 },
+      iconStyle: { color: '#333333' },
+    },
+    actions: {
+      onWebsitePress: jest.fn(),
+      onEmailPress: jest.fn(),
+      onMoreAppsPress: jest.fn(),
+    },
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    mockConsoleLog.mockClear();
+    mockConsoleError.mockClear();
+  });
+
+  describe('Complete Flow', () => {
+    it('should render complete about screen with all features', async () => {
+      const { getByText, queryByText } = render(
+        <AboutScreen config={fullConfig} />
+      );
+
+      // Should show loading initially
+      expect(getByText((content) => content.includes('Loading'))).toBeTruthy();
+
+      // Wait for content to load
+      await waitFor(() => {
+        expect(queryByText((content) => content.includes('Loading'))).toBeFalsy();
+      });
+
+      // Check header content
+      expect(getByText('Integration Test App')).toBeTruthy();
+      expect(getByText('Version 2.0.0')).toBeTruthy();
+      expect(getByText('This is an integration test app')).toBeTruthy();
+
+      // Check content items
+      expect(getByText('Developer')).toBeTruthy();
+      expect(getByText('Test Developer')).toBeTruthy();
+      expect(getByText('Contact')).toBeTruthy();
+      expect(getByText('integration@test.com')).toBeTruthy();
+      expect(getByText('Website')).toBeTruthy();
+      expect(getByText('integration.example.com')).toBeTruthy();
+      expect(getByText('More Apps')).toBeTruthy();
+    });
+
+    it('should handle all user interactions', async () => {
+      const { getByTestId } = render(
+        <AboutScreen config={fullConfig} />
+      );
+
+      // Wait for content to load
+      await waitFor(() => {
+        expect(getByTestId('email-item')).toBeTruthy();
+      });
+
+      // Test all interactions
+      fireEvent.click(getByTestId('email-item'));
+      fireEvent.click(getByTestId('website-item'));
+      fireEvent.click(getByTestId('more-apps-item'));
+
+      // Verify all actions were called
+      expect(fullConfig.actions!.onEmailPress).toHaveBeenCalledTimes(1);
+      expect(fullConfig.actions!.onWebsitePress).toHaveBeenCalledTimes(1);
+      expect(fullConfig.actions!.onMoreAppsPress).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Minimal Configuration', () => {
+    it('should work with minimal config', async () => {
+      const minimalConfig: AboutConfig = {
+        appInfo: {
+          name: 'Minimal App',
+          version: '1.0.0',
+        },
+      };
+
+      const { getByText, queryByText } = render(
+        <AboutScreen config={minimalConfig} />
+      );
+
+      await waitFor(() => {
+        expect(queryByText((content) => content.includes('Loading'))).toBeFalsy();
+      });
+
+      // Should show basic info
+      expect(getByText('Minimal App')).toBeTruthy();
+      expect(getByText('Version 1.0.0')).toBeTruthy();
+
+      // Should not show optional items
+      expect(queryByText('Developer')).toBeFalsy();
+      expect(queryByText('Contact')).toBeFalsy();
+      expect(queryByText('Website')).toBeFalsy();
+    });
+  });
+
+  describe('Custom Components', () => {
+    it('should render custom header and footer', async () => {
+      const CustomHeader = () => <View testID="custom-header"><Text>Custom Header</Text></View>;
+      const CustomFooter = () => <View testID="custom-footer"><Text>Custom Footer</Text></View>;
+
+      const { getByTestId, queryByText } = render(
+        <AboutScreen
+          config={fullConfig}
+          headerComponent={<CustomHeader />}
+          footerComponent={<CustomFooter />}
+          showHeader={false}
+        />
+      );
+
+      await waitFor(() => {
+        expect(queryByText((content) => content.includes('Loading'))).toBeFalsy();
+      });
+
+      // Should show custom components
+      expect(getByTestId('custom-header')).toBeTruthy();
+      expect(getByTestId('custom-footer')).toBeTruthy();
+
+      // Should not show default header
+      expect(queryByText('Integration Test App')).toBeFalsy();
+      expect(queryByText('Version 2.0.0')).toBeFalsy();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle invalid config gracefully', async () => {
+      const { queryByText, getByText } = render(
+        <AboutScreen config={null as unknown} />
+      );
+
+      await waitFor(() => {
+        expect(queryByText((content) => content.includes('Loading'))).toBeFalsy();
+      });
+
+      expect(getByText('No app information available')).toBeTruthy();
+    });
+
+    it('should handle missing actions gracefully', async () => {
+      const configWithoutActions: AboutConfig = {
+        appInfo: fullConfig.appInfo,
+      };
+
+      const { getByTestId } = render(
+        <AboutScreen config={configWithoutActions} />
+      );
+
+      await waitFor(() => {
+        expect(getByTestId('email-item')).toBeTruthy();
+      });
+
+      // Should not crash when pressing items without actions
+      expect(() => {
+        fireEvent.click(getByTestId('email-item'));
+        fireEvent.click(getByTestId('website-item'));
+      }).not.toThrow();
+    });
+  });
+
+  describe('Performance', () => {
+    it('should handle rapid re-renders', async () => {
+      const { rerender, getByText, queryByText } = render(
+        <AboutScreen config={fullConfig} />
+      );
+
+      await waitFor(() => {
+        expect(queryByText((content) => content.includes('Loading'))).toBeFalsy();
+      });
+
+      // Rapid re-renders with different configs
+      for (let i = 0; i < 5; i++) {
+        const newConfig = {
+          ...fullConfig,
+          appInfo: {
+            ...fullConfig.appInfo,
+            name: `App ${i}`,
+          },
+        };
+
+        rerender(<AboutScreen config={newConfig} />);
+
+        await waitFor(() => {
+          expect(getByText(`App ${i}`)).toBeTruthy();
+        });
+      }
+
+      // Should not crash and should show final state
+      expect(getByText('App 4')).toBeTruthy();
+    });
+
+    it('should handle prop changes efficiently', async () => {
+      const { rerender, getByText, queryByText } = render(
+        <AboutScreen config={fullConfig} />
+      );
+
+      await waitFor(() => {
+        expect(queryByText((content) => content.includes('Loading'))).toBeFalsy();
+      });
+
+      // Change showHeader prop
+      rerender(<AboutScreen config={fullConfig} showHeader={false} />);
+
+      await waitFor(() => {
+        expect(queryByText('Integration Test App')).toBeFalsy();
+      });
+
+      // Change back
+      rerender(<AboutScreen config={fullConfig} showHeader={true} />);
+
+      await waitFor(() => {
+        expect(getByText('Integration Test App')).toBeTruthy();
+      });
+    });
+  });
+
+  describe('Memory Management', () => {
+    it('should cleanup properly on unmount', async () => {
+      const { unmount, queryByText } = render(
+        <AboutScreen config={fullConfig} />
+      );
+
+      await waitFor(() => {
+        expect(queryByText((content) => content.includes('Loading'))).toBeFalsy();
+      });
+
+      // Should not throw when unmounting
+      expect(() => {
+        unmount();
+      }).not.toThrow();
+    });
+
+    it('should handle unmount during loading', () => {
+      const { unmount } = render(
+        <AboutScreen config={fullConfig} />
+      );
+
+      // Should not throw when unmounting during loading
+      expect(() => {
+        unmount();
+      }).not.toThrow();
+    });
+  });
+
+  describe('Accessibility', () => {
+    it('should have proper test IDs', async () => {
+      const { getByTestId } = render(
+        <AboutScreen config={fullConfig} testID="about-screen" />
+      );
+
+      await waitFor(() => {
+        expect(getByTestId('about-screen')).toBeTruthy();
+      });
+
+      // Check for item test IDs
+      expect(getByTestId('developer-item')).toBeTruthy();
+      expect(getByTestId('email-item')).toBeTruthy();
+      expect(getByTestId('website-item')).toBeTruthy();
+      expect(getByTestId('more-apps-item')).toBeTruthy();
+    });
+  });
+
+  describe('Console Logging', () => {
+    it('should log in development mode', async () => {
+      const originalDev = global.__DEV__;
+      global.__DEV__ = true;
+
+      render(<AboutScreen config={fullConfig} />);
+
+      await waitFor(() => {
+        expect(mockConsoleLog).toHaveBeenCalled();
+      });
+
+      global.__DEV__ = originalDev;
+    });
+
+    it('should not log in production mode', async () => {
+      const originalDev = global.__DEV__;
+      global.__DEV__ = false;
+
+      render(<AboutScreen config={fullConfig} />);
+
+      await waitFor(() => {
+        // Wait a bit to ensure no logging
+        expect(mockConsoleLog).not.toHaveBeenCalled();
+      });
+
+      global.__DEV__ = originalDev;
+    });
+  });
+});

package/src/domains/about/__tests__/types.d.ts

@@ -0,0 +1,5 @@
+declare global {
+  const __DEV__: boolean;
+}
+
+export {};

package/src/domains/about/domain/entities/AppInfo.ts

@@ -0,0 +1,74 @@
+/**
+ * Domain Entity - Application Information
+ * Pure business logic, no external dependencies
+ * Part of About Domain
+ */
+export interface AppInfo {
+  /** Application name */
+  name: string;
+  /** Application version (semver format) */
+  version: string;
+  /** Application description */
+  description?: string;
+  /** Developer/Company name */
+  developer?: string;
+  /** Contact email */
+  contactEmail?: string;
+  /** Website URL */
+  websiteUrl?: string;
+  /** Website display text */
+  websiteDisplay?: string;
+  /** More apps URL */
+  moreAppsUrl?: string;
+}
+
+/**
+ * Configuration interface for About component
+ * Fully configurable by parent application
+ */
+export interface AboutConfig {
+  /** Application information */
+  appInfo?: Partial<AppInfo>;
+  /** Custom theme colors */
+  theme?: {
+    primary?: string;
+    secondary?: string;
+    background?: string;
+    text?: string;
+    border?: string;
+  };
+  /** Custom styling options */
+  style?: {
+    containerStyle?: Record<string, unknown>;
+    itemStyle?: Record<string, unknown>;
+    textStyle?: Record<string, unknown>;
+    iconStyle?: Record<string, unknown>;
+  };
+  /** Custom actions */
+  actions?: {
+    onWebsitePress?: () => void;
+    onEmailPress?: () => void;
+    onMoreAppsPress?: () => void;
+  };
+  /** Localized texts for section headers and labels */
+  texts?: {
+    contact?: string;
+    more?: string;
+    developer?: string;
+    email?: string;
+    website?: string;
+    moreApps?: string;
+    loading?: string;
+    errorPrefix?: string;
+    noInfo?: string;
+    versionPrefix?: string;
+  };
+  /** Navigation route name */
+  route?: string;
+  /** Default navigation route name */
+  defaultRoute?: string;
+  /** Section title */
+  title?: string;
+  /** Section description */
+  description?: string;
+}

package/src/domains/about/domain/entities/__tests__/AppInfo.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Tests for AppInfo entity
+ */
+import { AppInfo } from '../AppInfo';
+
+describe('AppInfo Entity', () => {
+  const validAppInfo: AppInfo = {
+    name: 'Test App',
+    version: '1.0.0',
+    description: 'Test Description',
+    developer: 'Test Developer',
+    contactEmail: 'test@example.com',
+    websiteUrl: 'https://example.com',
+    websiteDisplay: 'example.com',
+    moreAppsUrl: 'https://apps.example.com',
+  };
+
+  describe('Validation', () => {
+    it('should accept valid AppInfo', () => {
+      expect(() => {
+        const appInfo: AppInfo = validAppInfo;
+        expect(appInfo.name).toBe('Test App');
+        expect(appInfo.version).toBe('1.0.0');
+      }).not.toThrow();
+    });
+
+    it('should accept minimal AppInfo', () => {
+      const minimalAppInfo: AppInfo = {
+        name: 'Minimal App',
+        version: '1.0.0',
+      };
+
+      expect(minimalAppInfo.name).toBe('Minimal App');
+      expect(minimalAppInfo.version).toBe('1.0.0');
+      expect(minimalAppInfo.description).toBeUndefined();
+      expect(minimalAppInfo.developer).toBeUndefined();
+    });
+
+    it('should accept AppInfo with optional fields', () => {
+      const appInfoWithOptionals: AppInfo = {
+        name: 'App',
+        version: '1.0.0',
+        description: 'Description',
+        developer: 'Developer',
+      };
+
+      expect(appInfoWithOptionals.description).toBe('Description');
+      expect(appInfoWithOptionals.developer).toBe('Developer');
+      expect(appInfoWithOptionals.contactEmail).toBeUndefined();
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('should have correct types', () => {
+      const appInfo: AppInfo = validAppInfo;
+
+      expect(typeof appInfo.name).toBe('string');
+      expect(typeof appInfo.version).toBe('string');
+      expect(typeof appInfo.description).toBe('string');
+      expect(typeof appInfo.developer).toBe('string');
+      expect(typeof appInfo.contactEmail).toBe('string');
+      expect(typeof appInfo.websiteUrl).toBe('string');
+      expect(typeof appInfo.websiteDisplay).toBe('string');
+      expect(typeof appInfo.moreAppsUrl).toBe('string');
+    });
+
+    it('should allow undefined for optional fields', () => {
+      const appInfo: AppInfo = {
+        name: 'Test',
+        version: '1.0.0',
+        description: undefined,
+        developer: undefined,
+        contactEmail: undefined,
+        websiteUrl: undefined,
+        websiteDisplay: undefined,
+        moreAppsUrl: undefined,
+      };
+
+      expect(appInfo.description).toBeUndefined();
+      expect(appInfo.developer).toBeUndefined();
+    });
+  });
+
+  describe('Immutability', () => {
+    it('should be assignable but not inherently immutable', () => {
+      const appInfo: AppInfo = { ...validAppInfo };
+
+      // TypeScript allows mutation but we can test the behavior
+      appInfo.name = 'Modified App';
+      expect(appInfo.name).toBe('Modified App');
+    });
+  });
+});

package/src/domains/about/domain/repositories/IAboutRepository.ts

@@ -0,0 +1,22 @@
+/**
+ * Repository interface for About data
+ * Defines contract for data access layer
+ */
+import { AppInfo } from '../entities/AppInfo';
+
+export interface IAboutRepository {
+  /**
+   * Get application information
+   */
+  getAppInfo(): Promise<AppInfo>;
+  
+  /**
+   * Save application information
+   */
+  saveAppInfo(appInfo: AppInfo): Promise<void>;
+  
+  /**
+   * Update application information
+   */
+  updateAppInfo(updates: Partial<AppInfo>): Promise<AppInfo>;
+}

package/src/domains/about/index.ts

@@ -0,0 +1,10 @@
+/**
+ * About Domain
+ * User information, app details, version info
+ */
+
+export * from './presentation/screens/AboutScreen';
+export * from './presentation/components/AboutContent';
+export * from './presentation/components/AboutSection';
+export * from './presentation/components/AboutSettingItem';
+export * from './presentation/components/AboutHeader';

package/src/domains/about/infrastructure/repositories/AboutRepository.ts

@@ -0,0 +1,68 @@
+/**
+ * Repository implementation for About data
+ * Handles data persistence and retrieval
+ * Optimized for performance and memory safety
+ */
+import { AppInfo } from '../../domain/entities/AppInfo';
+import { IAboutRepository } from '../../domain/repositories/IAboutRepository';
+
+export class AboutRepository implements IAboutRepository {
+  private appInfo: AppInfo | null = null;
+  private isDestroyed = false;
+
+  async getAppInfo(): Promise<AppInfo> {
+    if (this.isDestroyed) {
+      throw new Error('Repository has been destroyed');
+    }
+    
+    if (!this.appInfo) {
+      throw new Error('App info not initialized');
+    }
+    
+    // Return a deep copy to prevent mutations
+    return { ...this.appInfo };
+  }
+
+  async saveAppInfo(appInfo: AppInfo): Promise<void> {
+    if (this.isDestroyed) {
+      throw new Error('Repository has been destroyed');
+    }
+    
+    // Validate input to prevent invalid data
+    if (!appInfo || typeof appInfo !== 'object') {
+      throw new Error('Invalid app info provided');
+    }
+    
+    // Store a deep copy to prevent external mutations
+    this.appInfo = { ...appInfo };
+  }
+
+  async updateAppInfo(updates: Partial<AppInfo>): Promise<AppInfo> {
+    if (this.isDestroyed) {
+      throw new Error('Repository has been destroyed');
+    }
+    
+    if (!this.appInfo) {
+      throw new Error('App info not initialized');
+    }
+    
+    // Validate input to prevent invalid data
+    if (!updates || typeof updates !== 'object') {
+      throw new Error('Invalid updates provided');
+    }
+    
+    // Create new object to prevent mutations
+    this.appInfo = { ...this.appInfo, ...updates };
+
+    // Return a deep copy to prevent mutations
+    return { ...this.appInfo };
+  }
+
+  /**
+   * Cleanup method to prevent memory leaks
+   */
+  destroy(): void {
+    this.appInfo = null;
+    this.isDestroyed = true;
+  }
+}