@umituz/react-native-design-system 2.6.126 → 2.6.128

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "2.6.126",
+  "version": "2.6.128",
   "description": "Universal design system for React Native apps - Consolidated package with atoms, molecules, organisms, theme, typography, responsive, safe area, exception, infinite scroll, UUID, image, timezone and offline utilities",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -72,6 +72,7 @@
     "expo-font": ">=12.0.0",
     "expo-image": ">=3.0.0",
     "expo-network": ">=8.0.0",
+    "expo-secure-store": ">=14.0.0",
     "expo-sharing": ">=12.0.0",
     "react": ">=19.0.0",
     "react-native": ">=0.81.0",
@@ -123,6 +124,7 @@
     "expo-haptics": "~14.0.0",
     "expo-image": "~3.0.11",
     "expo-localization": "~16.0.1",
+    "expo-secure-store": "~14.0.0",
     "expo-sharing": "~14.0.8",
     "react": "19.1.0",
     "react-native": "0.81.5",

package/src/device/domain/entities/DeviceFeatureConfig.ts

@@ -0,0 +1,28 @@
+export type ResetPeriod = 'daily' | 'weekly' | 'monthly' | 'never';
+
+export interface FeatureLimit {
+  maxUses: number;
+  resetPeriod: ResetPeriod;
+}
+
+export interface DeviceFeatureConfig {
+  features: Record<string, FeatureLimit>;
+}
+
+export interface DeviceFeatureUsage {
+  usageCount: number;
+  lastResetAt: number;
+  firstUsedAt: number;
+}
+
+export interface DeviceFeatureAccess {
+  isAllowed: boolean;
+  remainingUses: number;
+  usageCount: number;
+  resetAt: number | null;
+  maxUses: number;
+}
+
+export const DEFAULT_FEATURE_CONFIG: DeviceFeatureConfig = {
+  features: {},
+};

package/src/device/index.ts

@@ -64,6 +64,16 @@ export {
 
 export { DeviceUtils } from './domain/entities/DeviceUtils';
 
+export type {
+    DeviceFeatureConfig,
+    DeviceFeatureUsage,
+    DeviceFeatureAccess,
+    FeatureLimit,
+    ResetPeriod,
+} from './domain/entities/DeviceFeatureConfig';
+
+export { DEFAULT_FEATURE_CONFIG } from './domain/entities/DeviceFeatureConfig';
+
 export { DeviceTypeUtils } from './domain/entities/DeviceTypeUtils';
 export { DeviceMemoryUtils } from './domain/entities/DeviceMemoryUtils';
 
@@ -75,8 +85,11 @@ export { DeviceService } from './infrastructure/services/DeviceService';
 export { UserFriendlyIdService } from './infrastructure/services/UserFriendlyIdService';
 import { PersistentDeviceIdService } from './infrastructure/services/PersistentDeviceIdService';
 export { PersistentDeviceIdService };
+export { DeviceFeatureService } from './infrastructure/services/DeviceFeatureService';
 export { collectDeviceExtras } from './infrastructure/services/DeviceExtrasCollector';
 export type { DeviceExtras } from './infrastructure/services/DeviceExtrasCollector';
+export { SecureDeviceIdRepository } from './infrastructure/repositories/SecureDeviceIdRepository';
+export { LegacyDeviceIdRepository } from './infrastructure/repositories/LegacyDeviceIdRepository';
 
 // ============================================================================
 // PRESENTATION - Device hooks
@@ -97,6 +110,8 @@ export type {
     UseAnonymousUserOptions,
 } from './presentation/hooks/useAnonymousUser';
 
+export { useDeviceFeatures } from './presentation/hooks/useDeviceFeatures';
+
 // ============================================================================
 // UTILITIES
 // ============================================================================

package/src/device/infrastructure/repositories/LegacyDeviceIdRepository.ts

@@ -0,0 +1,30 @@
+import { storageRepository, unwrap } from '@umituz/react-native-storage';
+
+const LEGACY_DEVICE_ID_KEY = '@device/persistent_id';
+
+export class LegacyDeviceIdRepository {
+  async get(): Promise<string | null> {
+    try {
+      const result = await storageRepository.getString(LEGACY_DEVICE_ID_KEY, '');
+      return unwrap(result, '') || null;
+    } catch {
+      return null;
+    }
+  }
+
+  async set(deviceId: string): Promise<void> {
+    try {
+      await storageRepository.setString(LEGACY_DEVICE_ID_KEY, deviceId);
+    } catch {
+      // Silent fail per CLAUDE.md rules
+    }
+  }
+
+  async remove(): Promise<void> {
+    try {
+      await storageRepository.removeItem(LEGACY_DEVICE_ID_KEY);
+    } catch {
+      // Silent fail
+    }
+  }
+}

package/src/device/infrastructure/repositories/SecureDeviceIdRepository.ts

@@ -0,0 +1,39 @@
+import * as SecureStore from 'expo-secure-store';
+
+const DEVICE_ID_KEY = '@device/persistent_id';
+const MIGRATION_FLAG_KEY = '@device/migration_completed';
+
+export class SecureDeviceIdRepository {
+  async get(): Promise<string | null> {
+    try {
+      return await SecureStore.getItemAsync(DEVICE_ID_KEY);
+    } catch {
+      return null;
+    }
+  }
+
+  async set(deviceId: string): Promise<void> {
+    try {
+      await SecureStore.setItemAsync(DEVICE_ID_KEY, deviceId);
+    } catch {
+      // Silent fail per CLAUDE.md rules
+    }
+  }
+
+  async hasMigrated(): Promise<boolean> {
+    try {
+      const flag = await SecureStore.getItemAsync(MIGRATION_FLAG_KEY);
+      return flag === 'true';
+    } catch {
+      return false;
+    }
+  }
+
+  async setMigrated(): Promise<void> {
+    try {
+      await SecureStore.setItemAsync(MIGRATION_FLAG_KEY, 'true');
+    } catch {
+      // Silent fail
+    }
+  }
+}

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

@@ -0,0 +1,176 @@
+/**
+ * Device Feature Service
+ *
+ * Generic service for tracking device-based feature usage.
+ * Apps configure feature limits via props, service tracks usage.
+ *
+ * @domain device
+ * @layer infrastructure/services
+ */
+
+import { storageRepository, unwrap } from '@umituz/react-native-storage';
+import type {
+  DeviceFeatureConfig,
+  DeviceFeatureUsage,
+  DeviceFeatureAccess,
+  FeatureLimit,
+  ResetPeriod,
+} from '../../domain/entities/DeviceFeatureConfig';
+import { PersistentDeviceIdService } from './PersistentDeviceIdService';
+
+export class DeviceFeatureService {
+  private static config: DeviceFeatureConfig = { features: {} };
+
+  static setConfig(config: DeviceFeatureConfig): void {
+    this.config = config;
+  }
+
+  static async checkFeatureAccess(
+    featureName: string
+  ): Promise<DeviceFeatureAccess> {
+    const deviceId = await PersistentDeviceIdService.getDeviceId();
+    const featureConfig = this.config.features[featureName];
+
+    if (!featureConfig) {
+      return {
+        isAllowed: true,
+        remainingUses: -1,
+        usageCount: 0,
+        resetAt: null,
+        maxUses: -1,
+      };
+    }
+
+    const usage = await this.getFeatureUsage(deviceId, featureName);
+    const shouldReset = this.shouldResetUsage(usage, featureConfig.resetPeriod);
+
+    if (shouldReset) {
+      await this.resetFeatureUsage(deviceId, featureName);
+      return {
+        isAllowed: true,
+        remainingUses: featureConfig.maxUses - 1,
+        usageCount: 0,
+        resetAt: this.calculateNextReset(featureConfig.resetPeriod),
+        maxUses: featureConfig.maxUses,
+      };
+    }
+
+    const isAllowed = usage.usageCount < featureConfig.maxUses;
+    const remainingUses = Math.max(
+      0,
+      featureConfig.maxUses - usage.usageCount
+    );
+
+    return {
+      isAllowed,
+      remainingUses,
+      usageCount: usage.usageCount,
+      resetAt: this.calculateNextReset(featureConfig.resetPeriod),
+      maxUses: featureConfig.maxUses,
+    };
+  }
+
+  static async incrementFeatureUsage(featureName: string): Promise<void> {
+    const deviceId = await PersistentDeviceIdService.getDeviceId();
+    const usage = await this.getFeatureUsage(deviceId, featureName);
+
+    const updatedUsage: DeviceFeatureUsage = {
+      ...usage,
+      usageCount: usage.usageCount + 1,
+    };
+
+    await this.setFeatureUsage(deviceId, featureName, updatedUsage);
+  }
+
+  private static async getFeatureUsage(
+    deviceId: string,
+    featureName: string
+  ): Promise<DeviceFeatureUsage> {
+    const key = this.getStorageKey(deviceId, featureName);
+    const now = Date.now();
+    const defaultUsage: DeviceFeatureUsage = {
+      usageCount: 0,
+      lastResetAt: now,
+      firstUsedAt: now,
+    };
+
+    try {
+      const result = await storageRepository.getItem<DeviceFeatureUsage>(
+        key,
+        defaultUsage
+      );
+      return unwrap(result, defaultUsage);
+    } catch {
+      return defaultUsage;
+    }
+  }
+
+  private static async setFeatureUsage(
+    deviceId: string,
+    featureName: string,
+    usage: DeviceFeatureUsage
+  ): Promise<void> {
+    const key = this.getStorageKey(deviceId, featureName);
+    try {
+      await storageRepository.setItem(key, usage);
+    } catch {
+      // Silent fail
+    }
+  }
+
+  private static async resetFeatureUsage(
+    deviceId: string,
+    featureName: string
+  ): Promise<void> {
+    const now = Date.now();
+    const usage = await this.getFeatureUsage(deviceId, featureName);
+
+    const resetUsage: DeviceFeatureUsage = {
+      ...usage,
+      usageCount: 0,
+      lastResetAt: now,
+    };
+
+    await this.setFeatureUsage(deviceId, featureName, resetUsage);
+  }
+
+  private static shouldResetUsage(
+    usage: DeviceFeatureUsage,
+    resetPeriod: ResetPeriod
+  ): boolean {
+    if (resetPeriod === 'never') {
+      return false;
+    }
+
+    const now = Date.now();
+    const timeSinceReset = now - usage.lastResetAt;
+    const periods: Record<ResetPeriod, number> = {
+      daily: 24 * 60 * 60 * 1000,
+      weekly: 7 * 24 * 60 * 60 * 1000,
+      monthly: 30 * 24 * 60 * 60 * 1000,
+      never: Infinity,
+    };
+
+    return timeSinceReset >= periods[resetPeriod];
+  }
+
+  private static calculateNextReset(resetPeriod: ResetPeriod): number | null {
+    if (resetPeriod === 'never') {
+      return null;
+    }
+
+    const now = Date.now();
+    const periods: Record<ResetPeriod, number> = {
+      daily: 24 * 60 * 60 * 1000,
+      weekly: 7 * 24 * 60 * 60 * 1000,
+      monthly: 30 * 24 * 60 * 60 * 1000,
+      never: 0,
+    };
+
+    return now + periods[resetPeriod];
+  }
+
+  private static getStorageKey(deviceId: string, featureName: string): string {
+    return `@device/feature/${deviceId}/${featureName}`;
+  }
+}

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

@@ -1,28 +1,20 @@
 /**
  * Persistent Device ID Service
  *
- * Provides a stable, persistent device identifier that survives app restarts.
- * Uses native device ID when available, falls back to generated UUID.
- * Stores the ID in AsyncStorage for persistence.
+ * Provides a stable device identifier that survives app reinstalls.
+ * Priority: SecureStore (survives reinstall) > Native ID > Generated UUID
  *
  * @domain device
  * @layer infrastructure/services
  */
 
-import { storageRepository, unwrap } from '@umituz/react-native-storage';
+import { SecureDeviceIdRepository } from '../repositories/SecureDeviceIdRepository';
+import { LegacyDeviceIdRepository } from '../repositories/LegacyDeviceIdRepository';
 import { DeviceIdService } from './DeviceIdService';
 
-const STORAGE_KEY = '@device/persistent_id';
-
-/** Cached ID to avoid repeated AsyncStorage reads */
 let cachedDeviceId: string | null = null;
-
-/** Promise to prevent race conditions during initialization */
 let initializationPromise: Promise<string> | null = null;
 
-/**
- * Generate a UUID v4 without external dependencies
- */
 function generateUUID(): string {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
     const r = (Math.random() * 16) | 0;
@@ -31,21 +23,10 @@ function generateUUID(): string {
   });
 }
 
-/**
- * Service for managing persistent device identifiers
- */
 export class PersistentDeviceIdService {
-  /**
-   * Get or create a persistent device ID
-   *
-   * This method:
-   * 1. Returns cached ID if available (fastest)
-   * 2. Checks AsyncStorage for previously stored ID
-   * 3. If not found, gets native device ID or generates UUID
-   * 4. Stores and caches the result for future calls
-   *
-   * Thread-safe: Multiple concurrent calls return the same promise
-   */
+  private static secureRepo = new SecureDeviceIdRepository();
+  private static legacyRepo = new LegacyDeviceIdRepository();
+
   static async getDeviceId(): Promise<string> {
     if (cachedDeviceId) {
       return cachedDeviceId;
@@ -59,21 +40,24 @@ export class PersistentDeviceIdService {
     return initializationPromise;
   }
 
-  /**
-   * Initialize and persist device ID
-   */
   private static async initializeDeviceId(): Promise<string> {
     try {
-      const result = await storageRepository.getString(STORAGE_KEY, '');
-      const storedId = unwrap(result, '');
+      const secureId = await this.secureRepo.get();
 
-      if (storedId) {
-        cachedDeviceId = storedId;
-        return storedId;
+      if (secureId) {
+        cachedDeviceId = secureId;
+        return secureId;
+      }
+
+      const migrated = await this.migrateFromLegacy();
+      if (migrated) {
+        cachedDeviceId = migrated;
+        return migrated;
       }
 
       const newId = await this.createNewDeviceId();
-      await storageRepository.setString(STORAGE_KEY, newId);
+      await this.secureRepo.set(newId);
+      await this.legacyRepo.set(newId);
       cachedDeviceId = newId;
 
       return newId;
@@ -84,9 +68,28 @@ export class PersistentDeviceIdService {
     }
   }
 
-  /**
-   * Create a new device ID from native source or generate one
-   */
+  private static async migrateFromLegacy(): Promise<string | null> {
+    try {
+      const hasMigrated = await this.secureRepo.hasMigrated();
+      if (hasMigrated) {
+        return null;
+      }
+
+      const legacyId = await this.legacyRepo.get();
+      if (!legacyId) {
+        await this.secureRepo.setMigrated();
+        return null;
+      }
+
+      await this.secureRepo.set(legacyId);
+      await this.secureRepo.setMigrated();
+
+      return legacyId;
+    } catch {
+      return null;
+    }
+  }
+
   private static async createNewDeviceId(): Promise<string> {
     const nativeId = await DeviceIdService.getDeviceId();
 
@@ -97,35 +100,25 @@ export class PersistentDeviceIdService {
     return `generated_${generateUUID()}`;
   }
 
-  /**
-   * Check if device ID exists in storage
-   */
   static async hasStoredId(): Promise<boolean> {
     try {
-      return await storageRepository.hasItem(STORAGE_KEY);
+      const secureId = await this.secureRepo.get();
+      return secureId !== null;
     } catch {
       return false;
     }
   }
 
-  /**
-   * Clear stored device ID (use with caution)
-   * This will generate a new ID on next getDeviceId() call
-   */
   static async clearStoredId(): Promise<void> {
     try {
-      await storageRepository.removeItem(STORAGE_KEY);
+      await this.legacyRepo.remove();
       cachedDeviceId = null;
       initializationPromise = null;
     } catch {
-      // Silent fail - non-critical operation
+      // Silent fail
     }
   }
 
-  /**
-   * Get the cached device ID without async operation
-   * Returns null if not yet initialized
-   */
   static getCachedId(): string | null {
     return cachedDeviceId;
   }

package/src/device/presentation/hooks/useDeviceFeatures.ts

@@ -0,0 +1,62 @@
+/**
+ * useDeviceFeatures Hook
+ *
+ * Hook for checking and tracking device-based feature usage.
+ * Main app provides feature configuration via DesignSystemProvider.
+ *
+ * @param featureName - Name of the feature to track
+ * @returns Feature access status and usage tracking functions
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+import { DeviceFeatureService } from '../../infrastructure/services/DeviceFeatureService';
+import type { DeviceFeatureAccess } from '../../domain/entities/DeviceFeatureConfig';
+
+interface UseDeviceFeaturesResult extends DeviceFeatureAccess {
+  incrementUsage: () => Promise<void>;
+  refresh: () => Promise<void>;
+}
+
+export function useDeviceFeatures(
+  featureName: string
+): UseDeviceFeaturesResult {
+  const [access, setAccess] = useState<DeviceFeatureAccess>({
+    isAllowed: true,
+    remainingUses: -1,
+    usageCount: 0,
+    resetAt: null,
+    maxUses: -1,
+  });
+
+  const checkAccess = useCallback(async () => {
+    try {
+      const result = await DeviceFeatureService.checkFeatureAccess(featureName);
+      setAccess(result);
+    } catch {
+      // Silent fail
+    }
+  }, [featureName]);
+
+  const incrementUsage = useCallback(async () => {
+    try {
+      await DeviceFeatureService.incrementFeatureUsage(featureName);
+      await checkAccess();
+    } catch {
+      // Silent fail
+    }
+  }, [featureName, checkAccess]);
+
+  const refresh = useCallback(async () => {
+    await checkAccess();
+  }, [checkAccess]);
+
+  useEffect(() => {
+    checkAccess();
+  }, [checkAccess]);
+
+  return {
+    ...access,
+    incrementUsage,
+    refresh,
+  };
+}

package/src/device/presentation/hooks/useDeviceInfo.ts

@@ -10,6 +10,7 @@
 
 import { useState, useEffect, useCallback } from 'react';
 import { DeviceService } from '../../infrastructure/services/DeviceService';
+import { PersistentDeviceIdService } from '../../infrastructure/services/PersistentDeviceIdService';
 import type { DeviceInfo, ApplicationInfo, SystemInfo } from '../../domain/entities/Device';
 
 
@@ -153,8 +154,9 @@ export const useDeviceCapabilities = () => {
 };
 
 /**
- * useDeviceId hook for device unique identifier
+ * useDeviceId hook for persistent device identifier
  *
+ * Returns device ID that survives app reinstalls (SecureStore).
  * WARNING: Use with caution - user privacy considerations!
  */
 export const useDeviceId = () => {
@@ -166,7 +168,7 @@ export const useDeviceId = () => {
       setIsLoading(true);
 
       try {
-        const id = await DeviceService.getDeviceId();
+        const id = await PersistentDeviceIdService.getDeviceId();
         setDeviceId(id);
       } catch {
         setDeviceId(null);

package/src/exports/device.ts

@@ -43,16 +43,26 @@ export {
   DeviceService,
   UserFriendlyIdService,
   PersistentDeviceIdService,
+  DeviceFeatureService,
+  SecureDeviceIdRepository,
+  LegacyDeviceIdRepository,
   useDeviceInfo,
   useDeviceCapabilities,
   useDeviceId,
   useAnonymousUser,
+  useDeviceFeatures,
   getAnonymousUserId,
   collectDeviceExtras,
+  DEFAULT_FEATURE_CONFIG,
   type DeviceInfo,
   type ApplicationInfo,
   type SystemInfo,
   type AnonymousUser,
   type UseAnonymousUserOptions,
   type DeviceExtras,
+  type DeviceFeatureConfig,
+  type DeviceFeatureUsage,
+  type DeviceFeatureAccess,
+  type FeatureLimit,
+  type ResetPeriod,
 } from '../device';