@umituz/react-native-design-system 2.3.0 → 2.3.2

package/src/device/domain/entities/__tests__/DeviceMemoryUtils.test.ts

@@ -0,0 +1,118 @@
+/**
+ * Device Memory Utils Tests
+ */
+
+import { DeviceMemoryUtils } from '../DeviceMemoryUtils';
+
+describe('DeviceMemoryUtils', () => {
+  describe('bytesToGB', () => {
+    it('should convert bytes to gigabytes', () => {
+      const bytes = 6442450944; // 6GB
+      const result = DeviceMemoryUtils.bytesToGB(bytes);
+      expect(result).toBe(6);
+    });
+
+    it('should handle decimal values', () => {
+      const bytes = 3221225472; // 3GB
+      const result = DeviceMemoryUtils.bytesToGB(bytes);
+      expect(result).toBe(3);
+    });
+  });
+
+  describe('bytesToMB', () => {
+    it('should convert bytes to megabytes', () => {
+      const bytes = 1048576; // 1MB
+      const result = DeviceMemoryUtils.bytesToMB(bytes);
+      expect(result).toBe(1);
+    });
+
+    it('should handle larger values', () => {
+      const bytes = 6442450944; // 6GB = 6144MB
+      const result = DeviceMemoryUtils.bytesToMB(bytes);
+      expect(result).toBe(6144);
+    });
+  });
+
+  describe('formatMemorySize', () => {
+    it('should format bytes in GB when >= 1GB', () => {
+      const bytes = 6442450944; // 6GB
+      const result = DeviceMemoryUtils.formatMemorySize(bytes);
+      expect(result).toBe('6.00 GB');
+    });
+
+    it('should format bytes in MB when < 1GB', () => {
+      const bytes = 524288000; // ~500MB
+      const result = DeviceMemoryUtils.formatMemorySize(bytes);
+      expect(result).toBe('500.00 MB');
+    });
+
+    it('should return Unknown for null bytes', () => {
+      const result = DeviceMemoryUtils.formatMemorySize(null);
+      expect(result).toBe('Unknown');
+    });
+
+    it('should format with 2 decimal places', () => {
+      const bytes = 15032385536; // 14GB
+      const result = DeviceMemoryUtils.formatMemorySize(bytes);
+      expect(result).toBe('14.00 GB');
+    });
+  });
+
+  describe('hasSufficientMemory', () => {
+    it('should return true when memory is sufficient', () => {
+      const totalMemory = 6442450944; // 6GB
+      const result = DeviceMemoryUtils.hasSufficientMemory(totalMemory, 4);
+      expect(result).toBe(true);
+    });
+
+    it('should return false when memory is insufficient', () => {
+      const totalMemory = 2147483648; // 2GB
+      const result = DeviceMemoryUtils.hasSufficientMemory(totalMemory, 4);
+      expect(result).toBe(false);
+    });
+
+    it('should return false for null memory', () => {
+      const result = DeviceMemoryUtils.hasSufficientMemory(null, 4);
+      expect(result).toBe(false);
+    });
+
+    it('should handle exact match', () => {
+      const totalMemory = 4294967296; // 4GB
+      const result = DeviceMemoryUtils.hasSufficientMemory(totalMemory, 4);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('getMemoryTier', () => {
+    it('should return high for >= 6GB', () => {
+      const totalMemory = 6442450944; // 6GB
+      const result = DeviceMemoryUtils.getMemoryTier(totalMemory);
+      expect(result).toBe('high');
+    });
+
+    it('should return mid for >= 3GB and < 6GB', () => {
+      const totalMemory = 4294967296; // 4GB
+      const result = DeviceMemoryUtils.getMemoryTier(totalMemory);
+      expect(result).toBe('mid');
+    });
+
+    it('should return low for < 3GB', () => {
+      const totalMemory = 2147483648; // 2GB
+      const result = DeviceMemoryUtils.getMemoryTier(totalMemory);
+      expect(result).toBe('low');
+    });
+
+    it('should return mid for null memory', () => {
+      const result = DeviceMemoryUtils.getMemoryTier(null);
+      expect(result).toBe('mid');
+    });
+
+    it('should handle boundary values', () => {
+      const exactly3GB = 3221225472; // 3GB
+      const exactly6GB = 6442450944; // 6GB
+      
+      expect(DeviceMemoryUtils.getMemoryTier(exactly3GB)).toBe('mid');
+      expect(DeviceMemoryUtils.getMemoryTier(exactly6GB)).toBe('high');
+    });
+  });
+});

package/src/device/domain/entities/__tests__/DeviceTypeUtils.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Device Type Utils Tests
+ */
+
+import { DeviceTypeUtils } from '../DeviceTypeUtils';
+import { DEVICE_CONSTANTS } from '../Device';
+
+describe('DeviceTypeUtils', () => {
+  describe('isTablet', () => {
+    it('should return true for tablet device', () => {
+      expect(DeviceTypeUtils.isTablet(DEVICE_CONSTANTS.DEVICE_TYPE.TABLET)).toBe(true);
+    });
+
+    it('should return false for phone device', () => {
+      expect(DeviceTypeUtils.isTablet(DEVICE_CONSTANTS.DEVICE_TYPE.PHONE)).toBe(false);
+    });
+
+    it('should return false for null device type', () => {
+      expect(DeviceTypeUtils.isTablet(null)).toBe(false);
+    });
+  });
+
+  describe('isPhone', () => {
+    it('should return true for phone device', () => {
+      expect(DeviceTypeUtils.isPhone(DEVICE_CONSTANTS.DEVICE_TYPE.PHONE)).toBe(true);
+    });
+
+    it('should return false for tablet device', () => {
+      expect(DeviceTypeUtils.isPhone(DEVICE_CONSTANTS.DEVICE_TYPE.TABLET)).toBe(false);
+    });
+
+    it('should return false for null device type', () => {
+      expect(DeviceTypeUtils.isPhone(null)).toBe(false);
+    });
+  });
+
+  describe('isDesktop', () => {
+    it('should return true for desktop device', () => {
+      expect(DeviceTypeUtils.isDesktop(DEVICE_CONSTANTS.DEVICE_TYPE.DESKTOP)).toBe(true);
+    });
+
+    it('should return false for phone device', () => {
+      expect(DeviceTypeUtils.isDesktop(DEVICE_CONSTANTS.DEVICE_TYPE.PHONE)).toBe(false);
+    });
+
+    it('should return false for null device type', () => {
+      expect(DeviceTypeUtils.isDesktop(null)).toBe(false);
+    });
+  });
+
+  describe('isTV', () => {
+    it('should return true for TV device', () => {
+      expect(DeviceTypeUtils.isTV(DEVICE_CONSTANTS.DEVICE_TYPE.TV)).toBe(true);
+    });
+
+    it('should return false for phone device', () => {
+      expect(DeviceTypeUtils.isTV(DEVICE_CONSTANTS.DEVICE_TYPE.PHONE)).toBe(false);
+    });
+
+    it('should return false for null device type', () => {
+      expect(DeviceTypeUtils.isTV(null)).toBe(false);
+    });
+  });
+
+  describe('isUnknown', () => {
+    it('should return true for unknown device', () => {
+      expect(DeviceTypeUtils.isUnknown(DEVICE_CONSTANTS.DEVICE_TYPE.UNKNOWN)).toBe(true);
+    });
+
+    it('should return false for phone device', () => {
+      expect(DeviceTypeUtils.isUnknown(DEVICE_CONSTANTS.DEVICE_TYPE.PHONE)).toBe(false);
+    });
+
+    it('should return false for null device type', () => {
+      expect(DeviceTypeUtils.isUnknown(null)).toBe(false);
+    });
+  });
+
+  describe('getDeviceTypeName', () => {
+    it('should return Phone for phone device', () => {
+      expect(DeviceTypeUtils.getDeviceTypeName(DEVICE_CONSTANTS.DEVICE_TYPE.PHONE)).toBe('Phone');
+    });
+
+    it('should return Tablet for tablet device', () => {
+      expect(DeviceTypeUtils.getDeviceTypeName(DEVICE_CONSTANTS.DEVICE_TYPE.TABLET)).toBe('Tablet');
+    });
+
+    it('should return Desktop for desktop device', () => {
+      expect(DeviceTypeUtils.getDeviceTypeName(DEVICE_CONSTANTS.DEVICE_TYPE.DESKTOP)).toBe('Desktop');
+    });
+
+    it('should return TV for TV device', () => {
+      expect(DeviceTypeUtils.getDeviceTypeName(DEVICE_CONSTANTS.DEVICE_TYPE.TV)).toBe('TV');
+    });
+
+    it('should return Unknown for unknown device', () => {
+      expect(DeviceTypeUtils.getDeviceTypeName(DEVICE_CONSTANTS.DEVICE_TYPE.UNKNOWN)).toBe('Unknown');
+    });
+
+    it('should return Unknown for null device type', () => {
+      expect(DeviceTypeUtils.getDeviceTypeName(null)).toBe('Unknown');
+    });
+  });
+});

package/src/device/domain/entities/__tests__/DeviceUtils.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Device Utils Tests
+ */
+
+import { DeviceUtils, DEVICE_CONSTANTS } from '../Device';
+
+describe('DeviceUtils', () => {
+  const mockDeviceInfo = {
+    brand: 'Apple',
+    manufacturer: 'Apple',
+    modelName: 'iPhone 14',
+    modelId: 'iPhone14,1',
+    deviceName: 'Test iPhone',
+    deviceYearClass: 2022,
+    deviceType: DEVICE_CONSTANTS.DEVICE_TYPE.PHONE,
+    isDevice: true,
+    osName: 'iOS',
+    osVersion: '16.0',
+    osBuildId: '20A362',
+    platformApiLevel: null,
+    totalMemory: 6442450944, // 6GB
+    platform: 'ios' as const,
+  };
+
+  const mockAppInfo = {
+    applicationName: 'Test App',
+    applicationId: 'com.test.app',
+    nativeApplicationVersion: '1.0.0',
+    nativeBuildVersion: '100',
+    installTime: new Date('2023-01-01'),
+    lastUpdateTime: new Date('2023-01-15'),
+    androidId: null,
+    iosIdForVendor: 'test-ios-id',
+  };
+
+  describe('isPhysicalDevice', () => {
+    it('should return true for physical device', () => {
+      expect(DeviceUtils.isPhysicalDevice(true)).toBe(true);
+    });
+
+    it('should return false for simulator', () => {
+      expect(DeviceUtils.isPhysicalDevice(false)).toBe(false);
+    });
+  });
+
+  describe('getDeviceDisplayName', () => {
+    it('should return device name when available', () => {
+      const result = DeviceUtils.getDeviceDisplayName(mockDeviceInfo);
+      expect(result).toBe('Test iPhone');
+    });
+
+    it('should return model name when device name is null', () => {
+      const info = { ...mockDeviceInfo, deviceName: null };
+      const result = DeviceUtils.getDeviceDisplayName(info);
+      expect(result).toBe('iPhone 14');
+    });
+
+    it('should return brand and manufacturer when model name is null', () => {
+      const info = { ...mockDeviceInfo, deviceName: null, modelName: null };
+      const result = DeviceUtils.getDeviceDisplayName(info);
+      expect(result).toBe('Apple Apple');
+    });
+
+    it('should return Unknown Device when all info is null', () => {
+      const info = { ...mockDeviceInfo, deviceName: null, modelName: null, brand: null, manufacturer: null };
+      const result = DeviceUtils.getDeviceDisplayName(info);
+      expect(result).toBe('Unknown Device');
+    });
+  });
+
+  describe('getOSDisplayString', () => {
+    it('should return OS name and version', () => {
+      const result = DeviceUtils.getOSDisplayString(mockDeviceInfo);
+      expect(result).toBe('iOS 16.0');
+    });
+
+    it('should return OS name only when version is null', () => {
+      const info = { ...mockDeviceInfo, osVersion: null };
+      const result = DeviceUtils.getOSDisplayString(info);
+      expect(result).toBe('iOS');
+    });
+
+    it('should return Unknown OS when OS name is null', () => {
+      const info = { ...mockDeviceInfo, osName: null };
+      const result = DeviceUtils.getOSDisplayString(info);
+      expect(result).toBe('Unknown OS');
+    });
+  });
+
+  describe('getAppVersionString', () => {
+    it('should return version and build number', () => {
+      const result = DeviceUtils.getAppVersionString(mockAppInfo);
+      expect(result).toBe('1.0.0 (100)');
+    });
+
+    it('should return version only when build is null', () => {
+      const info = { ...mockAppInfo, nativeBuildVersion: null };
+      const result = DeviceUtils.getAppVersionString(info);
+      expect(result).toBe('1.0.0');
+    });
+
+    it('should return Unknown Version when version is null', () => {
+      const info = { ...mockAppInfo, nativeApplicationVersion: null };
+      const result = DeviceUtils.getAppVersionString(info);
+      expect(result).toBe('Unknown Version');
+    });
+  });
+
+  describe('meetsMinimumRequirements', () => {
+    it('should pass for device meeting all requirements', () => {
+      const result = DeviceUtils.meetsMinimumRequirements(mockDeviceInfo, 4);
+      expect(result.meets).toBe(true);
+      expect(result.reasons).toHaveLength(0);
+    });
+
+    it('should fail for simulator', () => {
+      const info = { ...mockDeviceInfo, isDevice: false };
+      const result = DeviceUtils.meetsMinimumRequirements(info, 1);
+      expect(result.meets).toBe(false);
+      expect(result.reasons).toContain('Running on simulator/emulator');
+    });
+
+    it('should fail for insufficient memory', () => {
+      const result = DeviceUtils.meetsMinimumRequirements(mockDeviceInfo, 8);
+      expect(result.meets).toBe(false);
+      expect(result.reasons[0]).toContain('Insufficient memory');
+    });
+
+    it('should fail for old device', () => {
+      const info = { ...mockDeviceInfo, deviceYearClass: 2016 };
+      const result = DeviceUtils.meetsMinimumRequirements(info, 1);
+      expect(result.meets).toBe(false);
+      expect(result.reasons[0]).toContain('Device too old: 2016');
+    });
+  });
+
+  describe('getDeviceTier', () => {
+    it('should return high for new device', () => {
+      const result = DeviceUtils.getDeviceTier(mockDeviceInfo);
+      expect(result).toBe('high');
+    });
+
+    it('should return mid for 2020 device', () => {
+      const info = { ...mockDeviceInfo, deviceYearClass: 2020 };
+      const result = DeviceUtils.getDeviceTier(info);
+      expect(result).toBe('mid');
+    });
+
+    it('should return low for old device', () => {
+      const info = { ...mockDeviceInfo, deviceYearClass: 2017 };
+      const result = DeviceUtils.getDeviceTier(info);
+      expect(result).toBe('low');
+    });
+
+    it('should classify by memory when year is null', () => {
+      const info = { ...mockDeviceInfo, deviceYearClass: null, totalMemory: 8589934592 }; // 8GB
+      const result = DeviceUtils.getDeviceTier(info);
+      expect(result).toBe('high');
+    });
+
+    it('should return mid when no info available', () => {
+      const info = { ...mockDeviceInfo, deviceYearClass: null, totalMemory: null };
+      const result = DeviceUtils.getDeviceTier(info);
+      expect(result).toBe('mid');
+    });
+  });
+});

package/src/device/index.ts

@@ -0,0 +1,51 @@
+/**
+ * Device Module - Public API
+ *
+ * Device and application information utilities.
+ * Provides device detection, capabilities, and system info.
+ */
+
+// Domain entities
+export type {
+    DeviceInfo,
+    ApplicationInfo,
+    SystemInfo,
+    DeviceType,
+} from './domain/entities/Device';
+
+export {
+    DEVICE_CONSTANTS,
+    DeviceUtils,
+} from './domain/entities/Device';
+
+export { DeviceTypeUtils } from './domain/entities/DeviceTypeUtils';
+export { DeviceMemoryUtils } from './domain/entities/DeviceMemoryUtils';
+
+// Infrastructure services
+export { DeviceService } from './infrastructure/services/DeviceService';
+export { UserFriendlyIdService } from './infrastructure/services/UserFriendlyIdService';
+import { PersistentDeviceIdService } from './infrastructure/services/PersistentDeviceIdService';
+export { PersistentDeviceIdService };
+
+// Presentation hooks
+export {
+    useDeviceInfo,
+    useDeviceCapabilities,
+    useDeviceId,
+} from './presentation/hooks/useDeviceInfo';
+
+export {
+    useAnonymousUser,
+} from './presentation/hooks/useAnonymousUser';
+
+export type {
+    AnonymousUser,
+    UseAnonymousUserOptions,
+} from './presentation/hooks/useAnonymousUser';
+
+/**
+ * Get anonymous user ID for services
+ */
+export async function getAnonymousUserId(): Promise<string> {
+    return PersistentDeviceIdService.getDeviceId();
+}

package/src/device/infrastructure/services/ApplicationInfoService.ts

@@ -0,0 +1,86 @@
+/**
+ * Application Info Service
+ *
+ * Single Responsibility: Get application information from native modules
+ * Follows SOLID principles - only handles application info retrieval
+ */
+
+import * as Application from 'expo-application';
+import { Platform } from 'react-native';
+import type { ApplicationInfo } from '../../domain/entities/Device';
+import { safeAccess, withTimeout } from '../utils/nativeModuleUtils';
+
+/**
+ * Service for retrieving application information
+ */
+export class ApplicationInfoService {
+  /**
+   * Get application information
+   * SAFE: Returns minimal info if native modules are not ready
+   */
+  static async getApplicationInfo(): Promise<ApplicationInfo> {
+    try {
+      const [installTime, lastUpdateTime] = await Promise.all([
+        withTimeout(() => Application.getInstallationTimeAsync(), 1000),
+        withTimeout(() => Application.getLastUpdateTimeAsync(), 1000),
+      ]);
+
+      const applicationName = safeAccess(() => Application.applicationName, 'Unknown');
+      const applicationId = safeAccess(() => Application.applicationId, 'Unknown');
+      const nativeApplicationVersion = safeAccess(
+        () => Application.nativeApplicationVersion,
+        null,
+      );
+      const nativeBuildVersion = safeAccess(
+        () => Application.nativeBuildVersion,
+        null,
+      );
+
+      let androidId: string | null = null;
+      let iosIdForVendor: string | null = null;
+
+      if (Platform.OS === 'android') {
+        const result = await withTimeout(async () => Application.getAndroidId(), 1000);
+        androidId = result || null;
+      }
+
+      if (Platform.OS === 'ios') {
+        const result = await withTimeout(
+          async () => Application.getIosIdForVendorAsync(),
+          1000,
+        );
+        iosIdForVendor = result || null;
+      }
+
+      return {
+        applicationName: applicationName || 'Unknown',
+        applicationId: applicationId || 'Unknown',
+        nativeApplicationVersion,
+        nativeBuildVersion,
+        installTime,
+        lastUpdateTime,
+        androidId,
+        iosIdForVendor,
+      };
+    } catch {
+      return this.getMinimalApplicationInfo();
+    }
+  }
+
+  /**
+   * Get minimal application info (fallback)
+   */
+  private static getMinimalApplicationInfo(): ApplicationInfo {
+    return {
+      applicationName: 'Unknown',
+      applicationId: 'Unknown',
+      nativeApplicationVersion: null,
+      nativeBuildVersion: null,
+      installTime: null,
+      lastUpdateTime: null,
+      androidId: null,
+      iosIdForVendor: null,
+    };
+  }
+}
+

package/src/device/infrastructure/services/DeviceCapabilityService.ts

@@ -0,0 +1,60 @@
+/**
+ * Device Capability Service
+ *
+ * Single Responsibility: Check device capabilities and features
+ * Follows SOLID principles - only handles capability checks
+ */
+
+import * as Device from 'expo-device';
+import { Platform } from 'react-native';
+import { DeviceInfoService } from './DeviceInfoService';
+import { safeAccess } from '../utils/nativeModuleUtils';
+
+/**
+ * Service for checking device capabilities
+ */
+export class DeviceCapabilityService {
+  /**
+   * Check if device supports specific features
+   */
+  static async getDeviceCapabilities(): Promise<{
+    isDevice: boolean;
+    isTablet: boolean;
+    hasNotch: boolean;
+    totalMemoryGB: number | null;
+  }> {
+    const info = await DeviceInfoService.getDeviceInfo();
+
+    return {
+      isDevice: info.isDevice,
+      isTablet: info.deviceType === Device.DeviceType.TABLET,
+      hasNotch: await this.hasNotch(),
+      totalMemoryGB: info.totalMemory
+        ? info.totalMemory / (1024 * 1024 * 1024)
+        : null,
+    };
+  }
+
+  /**
+   * Check if device has notch/dynamic island
+   */
+  static async hasNotch(): Promise<boolean> {
+    try {
+      if (Platform.OS !== 'ios') {
+        return false;
+      }
+
+      const modelName = safeAccess(() => Device.modelName?.toLowerCase() || '', '');
+
+      // iPhone X and newer (with notch or dynamic island)
+      return (
+        modelName.includes('iphone x') ||
+        modelName.includes('iphone 1') || // 11, 12, 13, 14, 15
+        modelName.includes('pro')
+      );
+    } catch {
+      return false;
+    }
+  }
+}
+

package/src/device/infrastructure/services/DeviceIdService.ts

@@ -0,0 +1,70 @@
+/**
+ * Device ID Service
+ *
+ * Single Responsibility: Get device unique identifiers
+ * Follows SOLID principles - only handles device ID retrieval
+ */
+
+import * as Application from 'expo-application';
+import { Platform } from 'react-native';
+import { withTimeout } from '../utils/nativeModuleUtils';
+
+/**
+ * Service for retrieving device unique identifiers
+ */
+export class DeviceIdService {
+  /**
+   * Get device unique identifier (platform-specific)
+   *
+   * WARNING: Use with caution - user privacy considerations!
+   * Android: androidId (can be reset)
+   * iOS: iosIdForVendor (changes on reinstall)
+   * Web: null (not supported)
+   *
+   * SAFE: Returns null if native modules are not ready
+   */
+  static async getDeviceId(): Promise<string | null> {
+    try {
+      let deviceId: string | null = null;
+
+      if (Platform.OS === 'android') {
+        const result = await withTimeout(async () => Application.getAndroidId(), 1000);
+        deviceId = result || null;
+      }
+
+      if (Platform.OS === 'ios') {
+        const result = await withTimeout(
+          async () => Application.getIosIdForVendorAsync(),
+          1000,
+        );
+        deviceId = result || null;
+      }
+
+      return deviceId;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get offline user ID with fallback (iOS/Android only)
+   *
+   * For offline apps that need a persistent user ID:
+   * 1. Try to get platform-specific device ID (iOS/Android)
+   * 2. Fallback to a default offline user ID if device ID not available
+   *
+   * NOTE: Returns null for web platform (not supported)
+   */
+  static async getOfflineUserId(fallbackId: string = 'offline_user'): Promise<string | null> {
+    if (Platform.OS === 'web') {
+      return null;
+    }
+
+    const deviceId = await this.getDeviceId();
+    if (deviceId) {
+      return `offline_${deviceId}`;
+    }
+    return fallbackId;
+  }
+}
+