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

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;
+  }
+}
+

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

@@ -0,0 +1,95 @@
+/**
+ * Device Info Service
+ *
+ * Single Responsibility: Get device information from native modules
+ * Follows SOLID principles - only handles device info retrieval
+ */
+
+import * as Device from 'expo-device';
+import { Platform } from 'react-native';
+import * as Localization from 'expo-localization';
+import type { DeviceInfo } from '../../domain/entities/Device';
+import { safeAccess, withTimeout } from '../utils/nativeModuleUtils';
+
+/**
+ * Service for retrieving device information
+ */
+export class DeviceInfoService {
+  /**
+   * Get device information
+   * SAFE: Returns minimal info if native modules are not ready
+   */
+  static async getDeviceInfo(): Promise<DeviceInfo> {
+    try {
+      const totalMemory = await withTimeout(
+        () => Device.getMaxMemoryAsync(),
+        1000,
+      );
+
+      const brand = safeAccess(() => Device.brand, null);
+      const manufacturer = safeAccess(() => Device.manufacturer, null);
+      const modelName = safeAccess(() => Device.modelName, null);
+      const modelId = safeAccess(() => Device.modelId, null);
+      const deviceName = safeAccess(() => Device.deviceName, null);
+      const deviceYearClass = safeAccess(() => Device.deviceYearClass, null);
+      const deviceType = safeAccess(() => Device.deviceType, null);
+      const isDevice = safeAccess(() => Device.isDevice, false);
+      const osName = safeAccess(() => Device.osName, null);
+      const osVersion = safeAccess(() => Device.osVersion, null);
+      const osBuildId = safeAccess(() => Device.osBuildId, null);
+      const platformApiLevel = safeAccess(() => Device.platformApiLevel, null);
+
+      // Localization
+      const calendars = Localization.getCalendars();
+      const locales = Localization.getLocales();
+      const timezone = calendars?.[0]?.timeZone ?? null;
+      const region = locales?.[0]?.regionCode ?? null;
+
+      return {
+        brand,
+        manufacturer,
+        modelName,
+        modelId,
+        deviceName,
+        deviceYearClass,
+        deviceType,
+        isDevice,
+        osName,
+        osVersion,
+        osBuildId,
+        platformApiLevel,
+        totalMemory,
+        platform: Platform.OS as 'ios' | 'android' | 'web',
+        timezone,
+        region,
+      };
+    } catch {
+      return this.getMinimalDeviceInfo();
+    }
+  }
+
+  /**
+   * Get minimal device info (fallback)
+   */
+  private static getMinimalDeviceInfo(): DeviceInfo {
+    return {
+      brand: null,
+      manufacturer: null,
+      modelName: null,
+      modelId: null,
+      deviceName: null,
+      deviceYearClass: null,
+      deviceType: null,
+      isDevice: false,
+      osName: null,
+      osVersion: null,
+      osBuildId: null,
+      platformApiLevel: null,
+      totalMemory: null,
+      platform: Platform.OS as 'ios' | 'android' | 'web',
+      timezone: null,
+      region: null,
+    };
+  }
+}
+

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

@@ -0,0 +1,104 @@
+/**
+ * Device Service - Facade/Orchestrator
+ *
+ * Main entry point for device operations.
+ * Delegates to specialized services following Single Responsibility Principle.
+ *
+ * @domain device
+ * @layer infrastructure/services
+ */
+
+import type { DeviceInfo, ApplicationInfo, SystemInfo } from '../../domain/entities/Device';
+import { DeviceInfoService } from './DeviceInfoService';
+import { ApplicationInfoService } from './ApplicationInfoService';
+import { DeviceIdService } from './DeviceIdService';
+import { DeviceCapabilityService } from './DeviceCapabilityService';
+import { UserFriendlyIdService } from './UserFriendlyIdService';
+
+/**
+ * Device Service - Facade for all device operations
+ *
+ * This is a facade that delegates to specialized services.
+ * Each service has a single responsibility (SOLID principles).
+ */
+export class DeviceService {
+  /**
+   * Get device information
+   * Delegates to DeviceInfoService
+   */
+  static async getDeviceInfo(): Promise<DeviceInfo> {
+    return DeviceInfoService.getDeviceInfo();
+  }
+
+  /**
+   * Get application information
+   * Delegates to ApplicationInfoService
+   */
+  static async getApplicationInfo(): Promise<ApplicationInfo> {
+    return ApplicationInfoService.getApplicationInfo();
+  }
+
+  /**
+   * Get complete system information (device + app)
+   * @param options - Optional configuration
+   * @param options.userId - Optional user ID to include in system info
+   */
+  static async getSystemInfo(options?: { userId?: string }): Promise<SystemInfo> {
+    const [device, application] = await Promise.all([
+      DeviceInfoService.getDeviceInfo(),
+      ApplicationInfoService.getApplicationInfo(),
+    ]);
+
+    return {
+      device,
+      application,
+      timestamp: Date.now(),
+      ...(options?.userId && { userId: options.userId }),
+    };
+  }
+
+  /**
+   * Get device unique identifier (platform-specific)
+   * Delegates to DeviceIdService
+   */
+  static async getDeviceId(): Promise<string | null> {
+    return DeviceIdService.getDeviceId();
+  }
+
+  /**
+   * Get offline user ID with fallback
+   * Delegates to DeviceIdService
+   */
+  static async getOfflineUserId(fallbackId: string = 'offline_user'): Promise<string | null> {
+    return DeviceIdService.getOfflineUserId(fallbackId);
+  }
+
+  /**
+   * Check if device supports specific features
+   * Delegates to DeviceCapabilityService
+   */
+  static async getDeviceCapabilities(): Promise<{
+    isDevice: boolean;
+    isTablet: boolean;
+    hasNotch: boolean;
+    totalMemoryGB: number | null;
+  }> {
+    return DeviceCapabilityService.getDeviceCapabilities();
+  }
+
+  /**
+   * Check if device has notch/dynamic island
+   * Delegates to DeviceCapabilityService
+   */
+  static async hasNotch(): Promise<boolean> {
+    return DeviceCapabilityService.hasNotch();
+  }
+
+  /**
+   * Get user friendly device ID
+   * Delegates to UserFriendlyIdService
+   */
+  static async getUserFriendlyId(): Promise<string> {
+    return UserFriendlyIdService.getUserFriendlyId();
+  }
+}